KI & LLM 5. Mai 2026 12 min Lesezeit

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

LangChain.js ist das führende Framework für LLM-Anwendungen in JavaScript und TypeScript — Chains, Agents, Memory, RAG-Pipelines. Claude Code kennt alle Patterns: von einfachen Prompts bis zu komplexen Multi-Agent-Systemen.

Setup und erste Chain

ChainLLMChain: Der Einstieg

# Prompt: "Erstelle eine LangChain.js Chain die Tech-News zusammenfasst"

import { ChatAnthropic } from "@langchain/anthropic";
import { PromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const model = new ChatAnthropic({
  model: "claude-opus-4-6",
  temperature: 0.3,
});

const summaryPrompt = PromptTemplate.fromTemplate(`
  Fasse folgende Tech-News in 3 Bullet-Points zusammen:
  {news}
  
  Antworte auf Deutsch, präzise und informativ.
`);

// LCEL — LangChain Expression Language (moderner Ansatz)
const chain = summaryPrompt.pipe(model).pipe(new StringOutputParser());

const result = await chain.invoke({
  news: "OpenAI released GPT-5, Anthropic launched Claude 5..."
});

// Streaming
const stream = await chain.stream({ news: newsText });
for await (const chunk of stream) {
  process.stdout.write(chunk);
}

RAG: Retrieval-Augmented Generation

RAGEigene Wissensbasis mit Embeddings

# Prompt: "Baue eine RAG-Pipeline für eine Produktdokumentation"

import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { OpenAIEmbeddings } from "@langchain/openai";
import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { createRetrievalChain } from "langchain/chains/retrieval";
import { createStuffDocumentsChain } from "langchain/chains/combine_documents";

// 1. Dokumente aufteilen
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});
const docs = await splitter.createDocuments([productDocsText]);

// 2. Embeddings + VectorStore
const vectorStore = await MemoryVectorStore.fromDocuments(
  docs,
  new OpenAIEmbeddings()
);
const retriever = vectorStore.asRetriever({ k: 4 });

// 3. RAG Chain
const ragChain = await createRetrievalChain({
  retriever,
  combineDocsChain: await createStuffDocumentsChain({
    llm: model,
    prompt: PromptTemplate.fromTemplate(`
      Beantworte die Frage basierend auf dem Kontext:
      Kontext: {context}
      Frage: {input}
    `),
  }),
});

const answer = await ragChain.invoke({
  input: "Wie konfiguriere ich den API-Key?"
});

RAG-Prompt-Tipp: "Erstelle eine RAG-Pipeline mit [Vektordatenbank]. Optimiere Chunk-Size und Overlap für [Dokumenttyp]." Claude Code wählt automatisch optimale Splitter-Parameter und Retriever-Konfiguration.

Agents: LLMs die Tools nutzen

AgentTool-Calling Agent mit Websearch

# Prompt: "Agent der Preise vergleicht und Berechnungen macht"

import { createToolCallingAgent, AgentExecutor } from "langchain/agents";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Custom Tools
const getPriceTool = tool(
  async ({ productId }) => {
    const price = await fetchPrice(productId);
    return `Preis für ${productId}: €${price}`;
  },
  {
    name: "get_price",
    description: "Ruft den aktuellen Preis eines Produkts ab",
    schema: z.object({ productId: z.string() }),
  }
);

const calculateTool = tool(
  ({ expression }) => String(eval(expression)),
  {
    name: "calculate",
    description: "Berechnet mathematische Ausdrücke",
    schema: z.object({ expression: z.string() }),
  }
);

const agent = await createToolCallingAgent({
  llm: model,
  tools: [getPriceTool, calculateTool],
  prompt: ChatPromptTemplate.fromMessages([
    ["system", "Du bist ein hilfreicher Preisvergleichs-Assistent."],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
  ]),
});

const executor = new AgentExecutor({ agent, tools: [getPriceTool, calculateTool] });
const result = await executor.invoke({
  input: "Vergleiche die Preise von prod-123 und prod-456, was ist günstiger?"
});

Conversation Memory

MemoryGesprächskontext über Turns

# Prompt: "Chatbot der sich Gesprächskontext merkt"

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

const memory = new BufferWindowMemory({
  k: 5,           // Nur letzte 5 Turns behalten
  returnMessages: true,
  memoryKey: "history",
});

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

// Turn 1
await conversation.invoke({ input: "Mein Name ist Clara." });
// Turn 2 — erinnert sich an "Clara"
const r = await conversation.invoke({ input: "Wie heisse ich?" });
console.log(r.response); // "Du heißt Clara."

// Persistente Memory mit Redis
import { RedisChatMessageHistory } from "@langchain/redis";
const memory = new BufferWindowMemory({
  chatHistory: new RedisChatMessageHistory({
    sessionId: userId,
    sessionTTL: 3600,  // 1h Ablauf
  }),
  k: 10,
});

Memory-Limit: BufferMemory wächst unbegrenzt — für lange Gespräche BufferWindowMemory (letzte N Turns) oder SummaryMemory (LLM fasst ältere Turns zusammen). Claude Code kennt alle Memory-Typen und wählt den richtigen.

LangSmith: Observability für LLM-Chains

# Tracing mit LangSmith — Claude Code integriert es automatisch
# .env:
# LANGCHAIN_TRACING_V2=true
# LANGCHAIN_API_KEY=lsv2_...
# LANGCHAIN_PROJECT=my-app

# Jeder chain.invoke() wird automatisch getrackt:
# - Token-Verbrauch
# - Latenz pro Step
# - Input/Output jeder Chain-Stufe
# - Fehler und Retries

# Manueller Trace für Custom Logic:
import { traceable } from "langsmith/traceable";

const myFunction = traceable(async (input: string) => {
  // Wird in LangSmith als eigener Span getrackt
  return processInput(input);
}, { name: "processInput", project_name: "my-app" });

KI-Entwicklung im Kurs

Im Claude Code Mastery Kurs: vollständiges LangChain.js-Modul mit Chains, Agents, RAG-Pipelines, Memory-Management und LangSmith-Observability — inkl. Production-Best-Practices und Multi-Agent-Architekturen.

14 Tage kostenlos testen →