LangChain tool factories

make_langchain_tools wires a CodebaseMemory instance and an optional ImportGraph to a list of LangChain @tool-decorated callables. Pass the returned list directly into create_agent(tools=...) alongside your own tools. The factory shares the memory and graph objects you provide, so a finding stored in one step is available to the next recall in the same run.

from reasonblocks.integrations import make_langchain_tools

Installation

The LangChain integration requires langchain-core:

pip install reasonblocks langchain-core

make_langchain_tools

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

Returns a list of LangChain @tool callables. The list contains up to three tools (recall_findings, store_finding, impact_analysis) depending on which arguments and flags you provide.

Parameters

CodebaseMemory | None

default:"None"

The CodebaseMemory instance the tools read from and write to. When None, both recall_findings and store_finding are omitted from the returned list regardless of enable_recall and enable_store.

ImportGraph | None

default:"None"

Optional ImportGraph for the repository. When provided and enable_impact=True, an impact_analysis tool is added.

int

default:"5"

Maximum number of findings returned by a single recall_findings call.

float

default:"0.25"

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

bool

default:"true"

Include the recall_findings tool. Set to False to produce a write-only or impact-only tool set. Has no effect when memory is None.

bool

default:"true"

Include the store_finding tool. Set to False for read-only scenarios. Has no effect when memory is None.

bool

default:"true"

Include the impact_analysis tool when a graph is provided.

Returns

list

A list of LangChain @tool-decorated callables. Concatenate with your own tool list and pass to create_agent.

Tools

`recall_findings(query)`

Searches CodebaseMemory for findings relevant to query. The tool returns the same string that CodebaseMemory.format_recall() produces.

Parameter	Type	Description
`query`	`str`	Natural-language description of what you are looking for

`store_finding(content, file_path, finding_type)`

Persists a finding to CodebaseMemory. Returns "stored (id=<fid>)" on success or "store failed" on transport error.

Parameter	Type	Default	Description
`content`	`str`	—	The finding text (truncated to 8000 chars)
`file_path`	`str`	`""`	Repo-relative path (truncated to 512 chars)
`finding_type`	`str`	`"note"`	Short tag — `bug`, `behavior`, `pattern`, `note` (truncated to 64 chars)

`impact_analysis(file_path)`

Calls ImportGraph.format_impact() and returns the rendered string of dependents and dependencies.

Parameter	Type	Description
`file_path`	`str`	Repo-relative path, e.g. `"pydantic/main.py"`

impact_analysis is only present when you pass a non-None graph and enable_impact=True. Check len(rb_tools) rather than assuming a fixed index if you build the list conditionally.

Complete example

import pathlib
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic

from reasonblocks import CodebaseMemory, ImportGraph, ReasonBlocks
from reasonblocks.integrations import make_langchain_tools

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

rb_tools = make_langchain_tools(
    memory,
    graph,
    recall_top_k=8,
    recall_threshold=0.3,
)

model = ChatAnthropic(model="claude-haiku-4-5-20251001", max_tokens=1024)

with rb.middleware(
    run_id="run-1",
    agent_name="reviewer",
    task="Review PR #42",
    model="claude-haiku-4-5-20251001",
    codebase_id="my-repo",
) as mw:
    agent = create_agent(
        model=model,
        tools=[*rb_tools, *your_tools],
        system_prompt="You are a senior Python reviewer.",
        middleware=[mw],
    )
    result = agent.invoke({"messages": [("user", "Review PR #42")]})

rb_tools = make_langchain_tools(
    memory,
    graph,
    enable_store=False,
)

rb_tools = make_langchain_tools(memory)
# impact_analysis is omitted — graph is None

Build the tool list once per agent run, not once per process. The closure over memory and graph is fine to share across calls inside the same run, but each run typically wants its own CodebaseMemory instance scoped to the right codebase_id.

Getting Started

Concepts

Using ReasonBlocks

Connectors and sync

LangChain tool factories

Installation

make_langchain_tools

Parameters

Returns

Tools

`recall_findings(query)`

`store_finding(content, file_path, finding_type)`

`impact_analysis(file_path)`

Complete example

​Installation

​make_langchain_tools

​Parameters

​Returns

​Tools

​recall_findings(query)

​store_finding(content, file_path, finding_type)

​impact_analysis(file_path)

​Complete example

Installation

make_langchain_tools

Parameters

Returns

Tools

`recall_findings(query)`

`store_finding(content, file_path, finding_type)`

`impact_analysis(file_path)`

Complete example