LangChain.js

import { createRequire } from "node:module";
const require = createRequire(import.meta.url);
for (const name of ["langchain", "@langchain/core", "@langchain/langgraph", "@langchain/ollama", "@langchain/mcp-adapters", "@langchain/react", "@langchain/langgraph-checkpoint-postgres", "deepagents"]) {
  const { version, engines } = require(`${name}/package.json`);
  console.log(name.padEnd(42), version.padEnd(8), engines?.node ?? "");
}
const lc = await import("langchain");
const lg = await import("@langchain/langgraph");
console.log("langchain exports:", ["createAgent", "createMiddleware", "tool", "initChatModel", "fakeModel"].map((n) => `${n}=${typeof lc[n]}`).join(" "));
console.log("langgraph exports:", ["StateGraph", "StateSchema", "MessagesValue", "MemorySaver", "InMemoryStore", "Command", "interrupt"].map((n) => `${n}=${typeof lg[n]}`).join(" "));

langchain                                  1.5.14   >=20
@langchain/core                            1.2.13   >=20
@langchain/langgraph                       1.4.18   >=18
@langchain/ollama                          1.3.0    >=20
@langchain/mcp-adapters                    1.1.4    >=20.10.0
@langchain/react                           1.2.0
@langchain/langgraph-checkpoint-postgres   1.0.5    >=18
deepagents                                 1.14.1
langchain exports: createAgent=function createMiddleware=function tool=function initChatModel=function fakeModel=function
langgraph exports: StateGraph=function StateSchema=function MessagesValue=object MemorySaver=function InMemoryStore=function Command=function interrupt=function

import { createRequire } from "node:module";
const require = createRequire(import.meta.url);
const family = /^(langchain|deepagents|langsmith|@langchain\/)/;
for (const name of ["langchain", "@langchain/langgraph", "@langchain/ollama", "@langchain/mcp-adapters", "@langchain/react", "@langchain/langgraph-checkpoint-postgres", "deepagents"]) {
  const pkg = require(`${name}/package.json`);
  const show = (o = {}) => Object.keys(o).filter((d) => family.test(d)).sort();
  console.log(name.padEnd(42), "requires", show(pkg.dependencies).join(" ") || "-", "| peer:", show(pkg.peerDependencies).join(" ") || "-");
}

langchain                                  requires @langchain/langgraph @langchain/langgraph-checkpoint langsmith | peer: @langchain/core
@langchain/langgraph                       requires @langchain/langgraph-checkpoint @langchain/langgraph-sdk @langchain/protocol | peer: @langchain/core
@langchain/ollama                          requires - | peer: @langchain/core
@langchain/mcp-adapters                    requires - | peer: @langchain/core @langchain/langgraph
@langchain/react                           requires @langchain/langgraph-sdk | peer: @langchain/core
@langchain/langgraph-checkpoint-postgres   requires - | peer: @langchain/core @langchain/langgraph-checkpoint
deepagents                                 requires - | peer: @langchain/core @langchain/langgraph @langchain/langgraph-checkpoint @langchain/langgraph-sdk langchain langsmith

npm install langchain @langchain/core @langchain/langgraph @langchain/ollama zod
npm install --save-dev typescript @types/node

{"compilerOptions":{"target":"ES2022","module":"ESNext","moduleResolution":"Bundler","jsx":"react-jsx","strict":true,"noEmit":true,"skipLibCheck":true,"lib":["ES2022","DOM","DOM.Iterable"],"types":["node"]},"include":["*.ts","*.tsx"]}

import { ChatOllama, OllamaEmbeddings } from "@langchain/ollama";

// Reads OLLAMA_BASE_URL from the environment when set; defaults to http://127.0.0.1:11434.
export const chatModel = new ChatOllama({ model: "llama3.1:8b", temperature: 0 });
export const embeddings = new OllamaEmbeddings({ model: "nomic-embed-text" });

import { initChatModel } from "langchain";
const m = await initChatModel("ollama:llama3.1:8b", { temperature: 0 });
console.log(m.constructor.name);

ConfigurableModel

import { tool } from "langchain";
import * as z from "zod";

// A stub standing in for the pgvector-backed search built in "Integrating with LangChain".
const CORPUS = [
  { page: "modules/ROOT/pages/database/vector-rag/hnsw.adoc", section: "ef_search", content: "ef_search sets the size of the candidate list HNSW keeps while searching; raise it for recall, lower it for speed." },
  { page: "modules/ROOT/pages/database/vector-rag/hnsw.adoc", section: "m", content: "m is the number of bidirectional links per node in the HNSW graph." },
];

export const docsSearch = tool(
  async ({ query, limit }) => {
    const words = query.toLowerCase().split(/\s+/);
    const hits = CORPUS.filter((d) => words.some((w) => d.content.toLowerCase().includes(w))).slice(0, limit);
    return JSON.stringify({ results: hits.map((h) => ({ page: h.page, section: h.section, snippet: h.content.slice(0, 160) })) });
  },
  {
    name: "docs_search",
    description: "Search this site's documentation and return matching sections (page path, section, snippet).",
    schema: z.object({
      query: z.string().describe("A key phrase from the question, e.g. 'HNSW ef_search'"),
      limit: z.number().int().min(1).max(10).default(3),
    }),
  },
);

import { createAgent } from "langchain";
import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
import type { BaseCheckpointSaver } from "@langchain/langgraph";
import { docsSearch } from "./tools";

export function buildDocsAssistant(model: BaseChatModel | string, checkpointer?: BaseCheckpointSaver) {
  return createAgent({
    model,
    tools: [docsSearch],
    systemPrompt:
      "You are DocsAssistant. Answer only from documentation returned by docs_search, and cite the page path.",
    checkpointer,
    name: "docs_assistant",
  });
}

import { AIMessage, HumanMessage, fakeModel } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
import { buildDocsAssistant } from "./agent";

// Two scripted turns: first a tool call, then the final answer. No network, no Ollama.
const model = fakeModel()
  .respond(
    new AIMessage({
      content: "",
      tool_calls: [{ name: "docs_search", args: { query: "HNSW ef_search" }, id: "call_1", type: "tool_call" }],
    }),
  )
  .respond(new AIMessage("ef_search sets how many candidates HNSW keeps while searching (hnsw.adoc)."));

const agent = buildDocsAssistant(model, new MemorySaver());
const config = { configurable: { thread_id: "t-1" } }; // same thread_id = same conversation
const result = await agent.invoke({ messages: [new HumanMessage("What does ef_search do?")] }, config);

for (const m of result.messages) {
  const calls = AIMessage.isInstance(m) ? m.tool_calls?.map((c) => `${c.name}(${JSON.stringify(c.args)})`) : [];
  console.log(m.type.padEnd(5), calls?.length ? calls.join(", ") : String(m.content).slice(0, 72));
}

human What does ef_search do?
ai    docs_search({"query":"HNSW ef_search"})
tool  {"results":[{"page":"modules/ROOT/pages/database/vector-rag/hnsw.adoc","
ai    ef_search sets how many candidates HNSW keeps while searching (hnsw.adoc

import { AIMessage, HumanMessage, fakeModel } from "langchain";
import {
  Command, END, GraphNode, InMemoryStore, MemorySaver, MessagesValue, START, StateGraph, StateSchema, interrupt,
} from "@langchain/langgraph";
import * as z from "zod";
import { docsSearch } from "./tools";

const State = new StateSchema({
  messages: MessagesValue,               // built-in reducer: appends messages
  hits: z.array(z.string()).default(() => []),
  issueUrl: z.string().optional(),
});

const model = fakeModel().respond(new AIMessage("ef_search controls how many candidates HNSW keeps while searching."));

const retrieve: GraphNode<typeof State> = async (state) => {
  const question = String(state.messages.at(-1)?.content ?? "");
  const raw = JSON.parse(await docsSearch.invoke({ query: question, limit: 3 })) as { results: { page: string }[] };
  return { hits: raw.results.map((r) => r.page) };
};

const answer: GraphNode<typeof State> = async (state) => {
  const reply = await model.invoke([...state.messages, new HumanMessage(`Sources: ${state.hits.join(", ")}`)]);
  return { messages: [reply] };
};

const escalate: GraphNode<typeof State> = (state) => {
  // Pauses the run; the value is surfaced to the caller under __interrupt__.
  const approved = interrupt({ action: "create_github_issue", title: `Missing docs: ${state.messages.at(-1)?.content}` });
  return approved ? { issueUrl: "https://github.com/example/docs/issues/101" } : {};
};

const graph = new StateGraph(State)
  .addNode("retrieve", retrieve)
  .addNode("answer", answer)
  .addNode("escalate", escalate)
  .addEdge(START, "retrieve")
  .addConditionalEdges("retrieve", (state) => (state.hits.length > 0 ? "answer" : "escalate"), ["answer", "escalate"])
  .addEdge("answer", END)
  .addEdge("escalate", END)
  .compile({ checkpointer: new MemorySaver(), store: new InMemoryStore() });

const found = await graph.invoke({ messages: [new HumanMessage("HNSW ef_search")] }, { configurable: { thread_id: "g1" } });
console.log(found.hits.length, "hit(s);", String(found.messages.at(-1)?.content).slice(0, 40));

const config = { configurable: { thread_id: "g2" } };
const paused = await graph.invoke({ messages: [new HumanMessage("kubernetes operators")] }, config);
if ("__interrupt__" in paused) {
  console.log((paused.__interrupt__ as { value: unknown }[])[0].value);
}
const resumed = await graph.invoke(new Command({ resume: true }), config);
console.log(resumed.issueUrl);

2 hit(s); ef_search controls how many candidates H
{
  action: 'create_github_issue',
  title: 'Missing docs: kubernetes operators'
}
https://github.com/example/docs/issues/101

import { AIMessage, HumanMessage, fakeModel } from "langchain";
import { buildDocsAssistant } from "./agent";
import { MemorySaver } from "@langchain/langgraph";

const model = fakeModel()
  .respond(
    new AIMessage({
      content: "",
      tool_calls: [{ name: "docs_search", args: { query: "HNSW ef_search" }, id: "call_1", type: "tool_call" }],
    }),
  )
  .respond(new AIMessage("ef_search controls how many candidates HNSW keeps while searching."));

const agent = buildDocsAssistant(model, new MemorySaver());
const stream = await agent.streamEvents(
  { messages: [new HumanMessage("What does ef_search do?")] },
  { version: "v3", configurable: { thread_id: "t-stream" } },
);

await Promise.all([
  (async () => {
    for await (const message of stream.messages) {
      let text = "";
      for await (const delta of message.text) text += delta;
      console.log(`[${message.node}] ${text}`);
    }
  })(),
  (async () => {
    for await (const call of stream.toolCalls) {
      console.log(`tool ${call.name}(${JSON.stringify(call.input)})`);
      console.log("  ->", String(await call.output).slice(0, 80));
    }
  })(),
]);

const finalState = await stream.output;
console.log(finalState.messages.length, "messages in the final state");

[model_request]
tool docs_search({"query":"HNSW ef_search"})
  -> {"results":[{"page":"modules/ROOT/pages/database/vector-rag/hnsw.adoc","section"
[model_request] ef_search controls how many candidates HNSW keeps while searching.
4 messages in the final state

import { AIMessage, HumanMessage, fakeModel } from "langchain";
import { buildDocsAssistant } from "./agent";
import { MemorySaver } from "@langchain/langgraph";

const model = fakeModel()
  .respond(new AIMessage({ content: "", tool_calls: [{ name: "docs_search", args: { query: "HNSW ef_search" }, id: "call_1", type: "tool_call" }] }))
  .respond(new AIMessage("ef_search controls how many candidates HNSW keeps while searching."));

const agent = buildDocsAssistant(model, new MemorySaver());
const updates = await agent.stream(
  { messages: [new HumanMessage("What does ef_search do?")] },
  { streamMode: "updates", configurable: { thread_id: "t-modes" } },
);
for await (const chunk of updates) {
  for (const [node, update] of Object.entries(chunk)) {
    const last = (update as { messages: { type: string; content: unknown }[] }).messages.at(-1);
    console.log(node, "->", last?.type, JSON.stringify(last?.content).slice(0, 60));
  }
}

model_request -> ai ""
tools -> tool "{\"results\":[{\"page\":\"modules/ROOT/pages/database/vecto
model_request -> ai "ef_search controls how many candidates HNSW keeps while sea