Anthropic and Claude SDK tool factories

make_claude_tools() for the Anthropic Messages API and make_claude_agent_sdk_tools() for the Claude Agent SDK, both wiring CodebaseMemory and ImportGraph.

The Claude integration module provides two factory functions targeting different Anthropic surfaces. make_claude_tools targets the low-level anthropic Python package and returns a (tool_specs, dispatch) tuple you wire into a manual tool_use loop. make_claude_agent_sdk_tools targets the higher-level claude-agent-sdk package and returns @tool-decorated async functions you pass directly to query(...). Both factories expose the same CodebaseMemory and ImportGraph capabilities.

from reasonblocks.integrations.claude_tools import (
    make_claude_tools,
    make_claude_agent_sdk_tools,
    run_messages_agent_loop,
)

Anthropic Messages API

make_claude_tools

make_claude_tools(
    memory: CodebaseMemory,
    graph: ImportGraph | None = None,
    *,
    recall_top_k: int = 5,
    recall_threshold: float = 0.25,
    enable_store: bool = True,
    enable_impact: bool = True,
) -> tuple[list[dict], Callable[[str, dict], str]]

Returns a two-element tuple: a list of JSONSchema tool-spec dicts and a dispatch callable.

Parameters

memory · CodebaseMemory · required

The CodebaseMemory instance the tools read from and write to. Required — unlike the LangChain factory, memory cannot be None.

graph · ImportGraph | None · default: "None"

Optional ImportGraph. When provided and enable_impact=True, an impact_analysis spec is added to the tool list.

recall_top_k · int · default: "5"

Maximum number of findings returned by a single recall_findings call.

recall_threshold · float · default: "0.25"

Minimum similarity score (0–1) for a finding to be included in recall results.

enable_store · bool · default: "true"

Include the store_finding tool spec. Set to False for read-only scenarios.

enable_impact · bool · default: "true"

Include the impact_analysis tool spec when a graph is provided.

Returns

tool_specs · list[dict]

A list of {"name", "description", "input_schema"} dicts in the shape client.messages.create(tools=...) expects.

dispatch · Callable[[str, dict], str]

A callable dispatch(tool_name, tool_input) -> str that executes the named tool and returns its string result. Raises KeyError for unknown tool names so you can surface the model’s error cleanly. Exceptions inside the tool handler are caught and returned as an error string rather than propagated.

Manual tool-use loop

import anthropic
from reasonblocks.codebase_memory import CodebaseMemory
from reasonblocks.import_graph import ImportGraph
from reasonblocks.integrations.claude_tools import make_claude_tools

import pathlib

client = anthropic.Anthropic()
memory = CodebaseMemory(codebase_id="my-repo")
graph  = ImportGraph().build_from_files(
    {str(p): p.read_text() for p in pathlib.Path("myrepo").rglob("*.py")}
)

tool_specs, dispatch = make_claude_tools(memory, graph)

messages = [{"role": "user", "content": "Find the bug in auth/session.py"}]

while True:
    resp = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=4096,
        tools=tool_specs,
        messages=messages,
    )

    messages.append({"role": "assistant", "content": resp.content})

    if resp.stop_reason != "tool_use":
        break

    tool_results = []
    for block in resp.content:
        if block.type == "tool_use":
            result = dispatch(block.name, block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": result,
            })

    messages.append({"role": "user", "content": tool_results})

final_text = next(
    (b.text for b in resp.content if b.type == "text"), ""
)

run_messages_agent_loop

run_messages_agent_loop runs the full Anthropic Messages tool-use loop for you, handling every tool_use / tool_result turn automatically. Use it when you want batteries-included behavior without writing the loop yourself.

run_messages_agent_loop(
    client: Any,
    *,
    model: str,
    messages: list[dict],
    tool_specs: list[dict],
    dispatch: Callable[[str, dict], str],
    system: str = "",
    max_steps: int = 40,
    max_tokens: int = 4096,
) -> dict

Parameters

client · anthropic.Anthropic · required

A synchronous anthropic.Anthropic client instance. The helper uses client.messages.create internally.

model · str · required

The Anthropic model ID to use, e.g. "claude-opus-4-5" or "claude-haiku-3-5".

messages · list[dict] · required

Initial message list in Anthropic format. Typically [{"role": "user", "content": "..."}]. The helper appends assistant and tool-result turns in place; pass a copy if you want to preserve the original list.

tool_specs · list[dict] · required

The tool spec list returned by make_claude_tools.

dispatch · Callable[[str, dict], str] · required

The dispatch callable returned by make_claude_tools.

system · str · default: "\"\""

Optional system prompt. Passed as the system parameter to client.messages.create when non-empty.

max_steps · int · default: "40"

Maximum number of client.messages.create calls before the loop exits with stop_reason="max_steps". Prevents runaway loops from consuming your API quota.

max_tokens · int · default: "4096"

max_tokens value forwarded to every client.messages.create call.

Return value

final_text · str

The concatenated text from the last assistant turn that did not contain a tool_use block. Empty string if the run ended via max_steps with no text output.

messages · list[dict]

The full message history including all assistant turns and tool-result turns appended during the loop. Useful for continuing the conversation or for debugging.

stop_reason · str

The stop reason from the final API call, or "max_steps" if the loop was terminated by the step limit. Common values: "end_turn", "max_steps", "stop_sequence".

tool_calls · list[tuple[str, dict, str]]

Every tool call made during the loop as (tool_name, tool_input, result) tuples, in execution order. Useful for auditing what the agent did.

Example

from reasonblocks.integrations.claude_tools import make_claude_tools, run_messages_agent_loop

tool_specs, dispatch = make_claude_tools(memory, graph)

outcome = run_messages_agent_loop(
    client,
    model="claude-opus-4-5",
    messages=[{"role": "user", "content": "Audit the payment module"}],
    tool_specs=tool_specs,
    dispatch=dispatch,
    system="You are a senior Python code reviewer.",
    max_steps=30,
)

print(outcome["final_text"])
for name, inp, result in outcome["tool_calls"]:
    print(f"  {name}({inp}) → {result[:80]}")

Claude Agent SDK

make_claude_agent_sdk_tools

make_claude_agent_sdk_tools(
    memory: CodebaseMemory,
    graph: ImportGraph | None = None,
    *,
    recall_top_k: int = 5,
    recall_threshold: float = 0.25,
    enable_store: bool = True,
    enable_impact: bool = True,
) -> list

Returns a list of @tool-decorated async functions for the claude-agent-sdk package. The tool descriptors are in the shape ClaudeSDKClient / query(...) expects.

This function imports from claude_agent_sdk at call time. If the package is not installed, it raises ImportError with an install hint. Install with pip install claude-agent-sdk.

Parameters

memory · CodebaseMemory · required

The CodebaseMemory instance bound to the current run.

graph · ImportGraph | None · default: "None"

Optional ImportGraph. Adds impact_analysis when provided and enable_impact=True.

recall_top_k · int · default: "5"

Maximum number of findings returned per recall_findings call.

recall_threshold · float · default: "0.25"

Minimum similarity score (0–1) for recall results.

enable_store · bool · default: "true"

Include the store_finding tool. Set to False for read-only runs.

enable_impact · bool · default: "true"

Include impact_analysis when a graph is provided.

Returns

tools · list

A list of @tool-decorated async callables. Pass directly to query(tools=rb_tools + your_tools).

Example

from claude_agent_sdk import query
from reasonblocks.codebase_memory import CodebaseMemory
from reasonblocks.import_graph import ImportGraph
from reasonblocks.integrations.claude_tools import make_claude_agent_sdk_tools

import pathlib

memory = CodebaseMemory(codebase_id="my-repo")
graph  = ImportGraph().build_from_files(
    {str(p): p.read_text() for p in pathlib.Path("myrepo").rglob("*.py")}
)

rb_tools = make_claude_agent_sdk_tools(memory, graph)

async for message in query(
    prompt="Find and explain the auth bug",
    tools=rb_tools + your_tools,
):
    print(message)

Tools available in both factories

Both make_claude_tools and make_claude_agent_sdk_tools expose the same three tools:

Tool	Always included?	Description
recall_findings(query)	Yes (when memory set)	Search CodebaseMemory for findings matching a natural-language query
store_finding(content, file_path, finding_type)	When enable_store=True	Persist a new finding to CodebaseMemory
impact_analysis(file_path)	When graph is set and enable_impact=True	Return dependents and dependencies for a repo file