LangChain.js mit Claude Code: AI-Chains und Agents 2026

// Installation
// npm install langchain @langchain/anthropic @langchain/openai

import { ChatAnthropic } from "@langchain/anthropic";
import { PromptTemplate } from "@langchain/core/prompts";
import { LLMChain } from "langchain/chains";

// Modell initialisieren
const model = new ChatAnthropic({
  model: "claude-opus-4-5",
  temperature: 0.3,
  maxTokens: 1024,
});

// PromptTemplate definieren
const prompt = PromptTemplate.fromTemplate(
  "Du bist ein {rolle}. Beantworte folgende Frage auf Deutsch: {frage}"
);

// LLMChain zusammenbauen
const chain = new LLMChain({ llm: model, prompt });

// Chain aufrufen
const result = await chain.invoke({
  rolle: "TypeScript-Experte",
  frage: "Was sind die Vorteile von LangChain.js?",
});

console.log(result.text);
// → "LangChain.js bietet modulare Bausteine für AI-Applikationen..."

import { StringOutputParser } from "@langchain/core/output_parsers";

// LCEL-Syntax: prompt | model | parser
const chain = prompt
  .pipe(model)
  .pipe(new StringOutputParser());

const answer = await chain.invoke({
  rolle: "Senior Developer",
  frage: "Erkläre Dependency Injection kurz.",
});
console.log(answer); // direkt als String

import { ConversationBufferMemory } from "langchain/memory";
import { ConversationChain } from "langchain/chains";

const memory = new ConversationBufferMemory({
  returnMessages: true,
  memoryKey: "history",
});

const conversationChain = new ConversationChain({
  llm: model,
  memory,
});

// Erster Turn
await conversationChain.invoke({ input: "Ich heiße Max und lerne TypeScript." });

// Zweiter Turn — Memory ist aktiv!
const resp = await conversationChain.invoke({
  input: "Was ist mein Name?",
});
console.log(resp.response);
// → "Dein Name ist Max."

import { ConversationSummaryMemory } from "langchain/memory";

const summaryMemory = new ConversationSummaryMemory({
  llm: model,
  // fasst automatisch zusammen wenn History zu lang wird
  maxTokenLimit: 500,
});

// VectorStoreRetrieverMemory für semantischen Kontext
import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { OpenAIEmbeddings } from "@langchain/openai";
import { VectorStoreRetrieverMemory } from "langchain/memory";

const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());
const vectorMemory = new VectorStoreRetrieverMemory({
  vectorStoreRetriever: vectorStore.asRetriever(1),
  memoryKey: "relevant_history",
});

import { DynamicTool } from "@langchain/core/tools";
import { WikipediaQueryRun } from "@langchain/community/tools/wikipedia_query_run";
import { SerpAPI } from "@langchain/community/tools/serpapi";

// Wikipedia-Tool (out of the box)
const wikiTool = new WikipediaQueryRun({
  topKResults: 3,
  maxDocContentLength: 4000,
});

// SerpAPI für aktuelle Web-Suche
const searchTool = new SerpAPI(process.env.SERPAPI_KEY, {
  location: "Germany",
  hl: "de",
  gl: "de",
});

// Custom DynamicTool für eigene APIs
const weatherTool = new DynamicTool({
  name: "get_weather",
  description: "Gibt das aktuelle Wetter für eine Stadt zurück. Input: Stadtname",
  func: async (city: string) => {
    const res = await fetch(
      `https://api.weather.example.com/v1/current?city=${city}`
    );
    const data = await res.json();
    return `${data.temp}°C, ${data.description}`;
  },
});

const tools = [wikiTool, searchTool, weatherTool];

import { createReactAgent, AgentExecutor } from "langchain/agents";
import { pull } from "langchain/hub";

// ReAct-Prompt vom LangChain Hub laden
const reactPrompt = await pull("hwchase17/react");

// ReAct Agent erstellen
const reactAgent = await createReactAgent({
  llm: model,
  tools,
  prompt: reactPrompt,
});

const executor = new AgentExecutor({
  agent: reactAgent,
  tools,
  verbose: true,       // zeigt Reasoning-Schritte
  maxIterations: 5,   // Endlos-Loops verhindern
});

const agentResult = await executor.invoke({
  input: "Was ist die Hauptstadt von Bayern und wie ist das Wetter dort?",
});
console.log(agentResult.output);

import { createToolCallingAgent } from "langchain/agents";
import { ChatPromptTemplate } from "@langchain/core/prompts";

const toolCallingPrompt = ChatPromptTemplate.fromMessages([
  ["system", "Du bist ein hilfreicher Assistent mit Zugriff auf Tools."],
  ["human", "{input}"],
  ["placeholder", "{agent_scratchpad}"],
]);

const toolAgent = await createToolCallingAgent({
  llm: model,
  tools,
  prompt: toolCallingPrompt,
});

// Streaming aktivieren
const streamExecutor = new AgentExecutor({ agent: toolAgent, tools });
const stream = await streamExecutor.stream({ input: "Recherchiere LangChain.js Neuigkeiten" });

for await (const chunk of stream) {
  process.stdout.write(chunk.output ?? "");
}

import { PDFLoader } from "langchain/document_loaders/fs/pdf";
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { Chroma } from "@langchain/community/vectorstores/chroma";
import { OpenAIEmbeddings } from "@langchain/openai";
import { RetrievalQAChain } from "langchain/chains";

// 1. Dokument laden
const loader = new PDFLoader("./technische-dokumentation.pdf");
const docs = await loader.load();

// 2. Chunking
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});
const chunks = await splitter.splitDocuments(docs);

// 3. Embeddings + VectorStore (Chroma lokal)
const embeddings = new OpenAIEmbeddings({ model: "text-embedding-3-small" });
const vectorStore = await Chroma.fromDocuments(chunks, embeddings, {
  collectionName: "technische-doku",
});

// 4. RetrievalQA Chain
const ragChain = RetrievalQAChain.fromLLM(model, vectorStore.asRetriever(4), {
  returnSourceDocuments: true,
});

const ragResult = await ragChain.invoke({
  query: "Wie wird die Authentifizierung implementiert?",
});
console.log(ragResult.text);
console.log("Quellen:", ragResult.sourceDocuments.map(d => d.metadata.source));

import { MultiQueryRetriever } from "langchain/retrievers/multi_query";

const multiRetriever = MultiQueryRetriever.fromLLM({
  llm: model,
  retriever: vectorStore.asRetriever(),
  queryCount: 3,
  // generiert 3 Query-Varianten → höhere Recall-Rate
});

const relevantDocs = await multiRetriever.invoke(
  "Authentifizierung und Sicherheit"
);
console.log(`${relevantDocs.length} relevante Dokumente gefunden`);

import { StructuredOutputParser } from "langchain/output_parsers";
import { z } from "zod";

// 1. StructuredOutputParser mit Zod-Schema
const productParser = StructuredOutputParser.fromZodSchema(
  z.object({
    name: z.string().describe("Produktname"),
    preis: z.number().describe("Preis in Euro"),
    kategorie: z.enum(["Software", "Hardware", "Service"]),
    features: z.array(z.string()).describe("Liste der Features"),
  })
);

const structuredPrompt = PromptTemplate.fromTemplate(
  "Beschreibe folgendes Produkt strukturiert: {produkt}\n{format_instructions}"
);

const structuredChain = structuredPrompt
  .pipe(model)
  .pipe(productParser);

const product = await structuredChain.invoke({
  produkt: "Claude Code - AI-Coding-Assistent von Anthropic",
  format_instructions: productParser.getFormatInstructions(),
});
// product ist jetzt vollständig typisiert!
console.log(product.name, product.preis, product.features);

import { CommaSeparatedListOutputParser } from "@langchain/core/output_parsers";

const listParser = new CommaSeparatedListOutputParser();

const listChain = PromptTemplate.fromTemplate(
  "Nenne 5 TypeScript-Frameworks. Antworte nur mit einer kommagetrennten Liste: {topic}"
).pipe(model).pipe(listParser);

const frameworks = await listChain.invoke({ topic: "TypeScript Web Frameworks" });
console.log(frameworks);
// → ["Next.js", "Remix", "Astro", "NestJS", "Hono"]

// ZodOutputParser für komplexe verschachtelte Objekte
import { JsonOutputParser } from "@langchain/core/output_parsers";

const jsonParser = new JsonOutputParser();
const jsonChain = PromptTemplate.fromTemplate(
  "Gib Nutzerstatistiken als JSON zurück für: {app}"
).pipe(model).pipe(jsonParser);

const stats = await jsonChain.invoke({ app: "Agentic Movers" });
console.log(stats.dailyActiveUsers);