LangChain mit Claude Code: KI-Agenten & RAG-Pipelines 2026

LangChain hat sich 2026 zur meistgenutzten KI-Anwendungs-Bibliothek für TypeScript-Entwickler entwickelt. Kombiniert mit Claude Code als Entwicklungsumgebung entsteht ein leistungsstarkes Setup, um produktionsreife KI-Agenten, RAG-Pipelines und konversationelle Anwendungen zu bauen. In diesem Guide zeigen wir alle wichtigen LangChain-Konzepte mit echtem TypeScript-Code — von der ersten LLM-Verbindung bis zu LangSmith Tracing und Evaluation.

Was du in diesem Guide lernst:

LangChain.js Setup mit ChatAnthropic und ChatOpenAI in TypeScript
Prompt Templates, LCEL und RunnableSequence
Vollständige RAG-Pipeline mit Vector Store und Retrieval
Konversations-Memory (Buffer & Summary)
KI-Agenten mit Tools (Calculator, WebSearch, Custom)
LangSmith Tracing, Evaluation und Cost Tracking

1. LangChain Setup & LLM-Verbindung

Der erste Schritt ist die Installation der LangChain-Pakete und die Verbindung zu einem LLM-Provider. LangChain unterstützt sowohl Anthropic Claude als auch OpenAI — und lässt sich leicht zwischen beiden wechseln.

Installation

# LangChain Core + Provider-Pakete installieren
npm install langchain @langchain/core @langchain/anthropic @langchain/openai

# TypeScript + ts-node für die Entwicklung
npm install -D typescript ts-node @types/node

# tsconfig.json initialisieren
npx tsc --init

ChatAnthropic — Claude als LLM-Backend

import { ChatAnthropic } from "@langchain/anthropic";
import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";

// Claude 3.5 Sonnet als Chat-Modell initialisieren
const model = new ChatAnthropic({
  model: "claude-3-5-sonnet-20241022",
  apiKey: process.env.ANTHROPIC_API_KEY,
  maxTokens: 2048,
  temperature: 0.7,
});

// Einfacher invoke-Aufruf mit Nachrichten-Array
const response = await model.invoke([
  new SystemMessage("Du bist ein hilfreicher TypeScript-Experte."),
  new HumanMessage("Erkläre den Unterschied zwischen interface und type in TypeScript."),
]);

console.log(response.content);
// → "interface ist erweiterbar mit declaration merging, type ist flexibler..."

Streaming-Antworten in Echtzeit

// Streaming — Token für Token ausgeben
const stream = await model.stream([
  new HumanMessage("Schreibe eine kurze Erklärung zu async/await in TypeScript."),
]);

process.stdout.write("\nAntwort: ");
for await (const chunk of stream) {
  process.stdout.write(chunk.content as string);
}
console.log("\n--- Stream beendet ---");

Batch-Verarbeitung mehrerer Anfragen

// batch() — mehrere Prompts parallel verarbeiten
const fragen = [
  [new HumanMessage("Was ist ein TypeScript Generic?")],
  [new HumanMessage("Erkläre TypeScript Decorators.")],
  [new HumanMessage("Was sind Mapped Types?")],
];

const antworten = await model.batch(fragen);
antworten.forEach((a, i) => {
  console.log(`Frage ${i + 1}:`, a.content.slice(0, 100), "...");
});

ChatOpenAI als Alternative

import { ChatOpenAI } from "@langchain/openai";

// GPT-4o als Drop-in-Ersatz — gleiche API wie ChatAnthropic
const gpt = new ChatOpenAI({
  model: "gpt-4o",
  apiKey: process.env.OPENAI_API_KEY,
  temperature: 0.5,
});

// Identische invoke/stream/batch API — einfacher Provider-Wechsel
const result = await gpt.invoke("Was ist neu in TypeScript 5.4?");
console.log(result.content);

Tipp: In Claude Code kannst du per /terminal direkt im integrierten Terminal arbeiten. Setze die API-Keys als Umgebungsvariablen in einer .env-Datei und lade sie mit dotenv — dann wechselst du problemlos zwischen Anthropic und OpenAI.

2. Prompt Templates & Chains mit LCEL

Die LangChain Expression Language (LCEL) ist der moderne Weg, Chains zu bauen. Mit dem Pipe-Operator | verbindest du Komponenten zu wiederverwendbaren Pipelines — typsicher, composable und streamingfähig.

ChatPromptTemplate erstellen

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

const model = new ChatAnthropic({ model: "claude-3-5-sonnet-20241022" });

// Template mit Platzhaltern definieren
const promptTemplate = ChatPromptTemplate.fromMessages([
  ["system", "Du bist ein {sprache}-Experte. Antworte präzise und mit Codebeispielen."],
  ["human", "Erkläre {konzept} in maximal {woerter} Wörtern."],
]);

// LCEL — Pipe-Operator verbindet Bausteine
const chain = promptTemplate.pipe(model).pipe(new StringOutputParser());

// Chain aufrufen mit Template-Variablen
const ausgabe = await chain.invoke({
  sprache: "TypeScript",
  konzept: "Generics",
  woerter: "150",
});

console.log(ausgabe);
// → "TypeScript Generics ermöglichen typsichere, wiederverwendbare Funktionen..."

RunnableSequence — Explizite Chain-Komposition

import { RunnableSequence, RunnablePassthrough } from "@langchain/core/runnables";
import { StructuredOutputParser } from "langchain/output_parsers";
import { z } from "zod";

// Strukturierter Output-Parser mit Zod-Schema
const outputParser = StructuredOutputParser.fromZodSchema(
  z.object({
    erklarung: z.string().describe("Kurze Erklärung des Konzepts"),
    codebeispiel: z.string().describe("TypeScript Codebeispiel"),
    schwierigkeit: z.enum(["anfanger", "mittel", "fortgeschritten"]),
  })
);

const formatInstructions = outputParser.getFormatInstructions();

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "Du bist TypeScript-Lehrer. {format_instructions}"],
  ["human", "Erkläre: {thema}"],
]);

// Explizite Sequenz mit RunnableSequence
const strukturierteChain = RunnableSequence.from([
  {
    thema: new RunnablePassthrough(),
    format_instructions: () => formatInstructions,
  },
  prompt,
  model,
  outputParser,
]);

const ergebnis = await strukturierteChain.invoke("TypeScript Decorators");
console.log(ergebnis.erklarung);
console.log(ergebnis.codebeispiel);
console.log("Schwierigkeit:", ergebnis.schwierigkeit);

Parallele Chains mit RunnableMap

import { RunnableMap } from "@langchain/core/runnables";

// Zwei Chains parallel ausführen
const kurzChain = ChatPromptTemplate
  .fromTemplate("Erkläre {thema} in 2 Sätzen.")
  .pipe(model)
  .pipe(new StringOutputParser());

const codeChain = ChatPromptTemplate
  .fromTemplate("Zeige ein TypeScript-Codebeispiel für {thema}.")
  .pipe(model)
  .pipe(new StringOutputParser());

const parallelMap = RunnableMap.from({
  kurzerklarung: kurzChain,
  code: codeChain,
});

const output = await parallelMap.invoke({ thema: "Async Iterators" });
console.log("Kurz:", output.kurzerklarung);
console.log("Code:", output.code);

LCEL LCEL-Vorteile auf einen Blick

Automatisches Streaming über alle Chain-Komponenten
Native TypeScript-Typen — kein implizites any
Einfaches Testen einzelner Komponenten in Isolation
LangSmith Tracing ohne zusätzlichen Code

3. RAG-Pipeline mit Vector Store

Retrieval-Augmented Generation (RAG) ist das wichtigste Muster für wissensbasierte KI-Anwendungen. Du lädst Dokumente, teilst sie in Chunks auf, indexierst sie in einem Vector Store und rufst beim Chat nur die relevanten Passagen ab.

Dokumente laden und aufteilen

import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { Document } from "@langchain/core/documents";
import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { TextLoader } from "langchain/document_loaders/fs/text";

// PDF laden
const pdfLoader = new PDFLoader("./doku/typescript-handbuch.pdf");
const pdfDocs = await pdfLoader.load();

// Text-Splitter konfigurieren
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,      // Zeichen pro Chunk
  chunkOverlap: 200,    // Überlappung für Kontext-Kontinuität
  separators: ["\n\n", "\n", " ", ""],
});

const chunks = await splitter.splitDocuments(pdfDocs);
console.log(`${chunks.length} Chunks erstellt aus ${pdfDocs.length} PDF-Seiten`);

// Eigene Dokumente erstellen
const eigeneDocs: Document[] = [
  new Document({
    pageContent: "TypeScript 5.4 führt NoInfer Utility Type ein...",
    metadata: { quelle: "ts-5.4-release", datum: "2024-03" },
  }),
  new Document({
    pageContent: "Satisfies Operator wurde in TS 4.9 eingeführt...",
    metadata: { quelle: "ts-4.9-release", datum: "2022-11" },
  }),
];

Vector Store mit Embeddings befüllen

import { OpenAIEmbeddings } from "@langchain/openai";
import { MemoryVectorStore } from "langchain/vectorstores/memory";

// Embeddings-Modell (text-embedding-3-small ist kostengünstig)
const embeddings = new OpenAIEmbeddings({
  model: "text-embedding-3-small",
  apiKey: process.env.OPENAI_API_KEY,
});

// MemoryVectorStore — ideal für Prototyping und Tests
const vectorStore = await MemoryVectorStore.fromDocuments(
  [...chunks, ...eigeneDocs],
  embeddings
);

// Retriever erstellen — top-k ähnlichste Dokumente
const retriever = vectorStore.asRetriever({
  k: 5,
  searchType: "similarity",
});

// Test: Manuelle Similarity-Suche
const resultate = await vectorStore.similaritySearchWithScore(
  "TypeScript Generics Beispiel", 3
);
resultate.forEach(([doc, score]) => {
  console.log(`Score: ${score.toFixed(3)} | ${doc.pageContent.slice(0, 80)}...`);
});

RAG-Chain zusammenbauen

import { ChatPromptTemplate } from "@langchain/core/prompts";
import { RunnableSequence, RunnablePassthrough } from "@langchain/core/runnables";
import { StringOutputParser } from "@langchain/core/output_parsers";

// RAG-Prompt — Kontext aus Retriever einbetten
const ragPrompt = ChatPromptTemplate.fromMessages([
  [
    "system",
    `Du bist ein TypeScript-Experte. Beantworte die Frage NUR auf Basis des folgenden Kontexts.
Falls die Antwort nicht im Kontext enthalten ist, sage: "Diese Information liegt mir nicht vor."

Kontext:
{context}`,
  ],
  ["human", "{frage}"],
]);

// Hilfsfunktion: Docs zu String zusammenführen
const formatDocs = (docs: Document[]): string =>
  docs.map((d) => d.pageContent).join("\n\n---\n\n");

// Vollständige RAG-Chain mit LCEL
const ragChain = RunnableSequence.from([
  {
    context: retriever.pipe(formatDocs),
    frage: new RunnablePassthrough(),
  },
  ragPrompt,
  model,
  new StringOutputParser(),
]);

// RAG-Abfrage stellen
const antwort = await ragChain.invoke("Was ist der NoInfer Utility Type in TypeScript?");
console.log(antwort);

Produktion: Für Produktionsanwendungen ersetze MemoryVectorStore durch PineconeStore oder SupabaseVectorStore. Die API bleibt identisch — du tauschst nur den Import aus.

4. Konversations-Memory

Ohne Memory behandelt jeder LLM-Aufruf das Gespräch als neuen Start. LangChain bietet verschiedene Memory-Strategien — von einfachem Buffer-Memory bis zur automatischen Gesprächszusammenfassung für lange Chats.

BufferMemory — Gesprächshistorie im Arbeitsspeicher

import { BufferMemory, ChatMessageHistory } from "langchain/memory";
import { ConversationChain } from "langchain/chains";

const memory = new BufferMemory({
  memoryKey: "history",
  returnMessages: true,   // Messages als Array statt String
  humanPrefix: "Benutzer",
  aiPrefix: "Assistent",
});

const chatChain = new ConversationChain({
  llm: model,
  memory,
  verbose: false,
});

// Mehrere Turns im Gespräch
const turn1 = await chatChain.invoke({ input: "Mein Name ist Alex. Ich lerne TypeScript." });
console.log("Turn 1:", turn1.response);

const turn2 = await chatChain.invoke({ input: "Was habe ich dir gerade über mich erzählt?" });
console.log("Turn 2:", turn2.response);
// → "Du hast mir erzählt, dass dein Name Alex ist und du TypeScript lernst."

ChatMessageHistory — Externe Persistenz

import { ChatMessageHistory } from "langchain/stores/message/in_memory";
import { HumanMessage, AIMessage } from "@langchain/core/messages";

// Historie mit vorhandenen Nachrichten vorbelegen
const chatHistory = new ChatMessageHistory();
await chatHistory.addMessage(new HumanMessage("Ich arbeite mit Next.js 14."));
await chatHistory.addMessage(new AIMessage("Interessant! App Router oder Pages Router?"));

// Memory aus ChatHistory aufbauen
const memoryMitHistory = new BufferMemory({
  chatHistory,
  returnMessages: true,
  memoryKey: "history",
});

// Aktuelle Nachrichten abrufen
const { history } = await memoryMitHistory.loadMemoryVariables({});
console.log(`${history.length} Nachrichten in History`);

ConversationSummaryMemory für lange Chats

import { ConversationSummaryMemory } from "langchain/memory";

// Summary-Memory — fasst alte Turns zusammen statt sie zu stapeln
const summaryMemory = new ConversationSummaryMemory({
  llm: model,
  memoryKey: "history",
  returnMessages: true,
  maxTokenLimit: 500,   // Ab diesem Limit wird zusammengefasst
});

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

// Viele Turns — Memory bleibt schlank durch automatische Zusammenfassung
for (let i = 1; i <= 10; i++) {
  await summaryChain.invoke({
    input: `Frage ${i}: Erkläre TypeScript-Konzept Nummer ${i}.`,
  });
}

// Aktuelle Zusammenfassung anzeigen
const vars = await summaryMemory.loadMemoryVariables({});
console.log("Aktuelle Zusammenfassung:", vars.history);

createHistoryAwareRetriever — RAG mit Memory

import { createHistoryAwareRetriever } from "langchain/chains/history_aware_retriever";
import { MessagesPlaceholder } from "@langchain/core/prompts";

// Prompt für History-aware Retrieval
const contextualizePrompt = ChatPromptTemplate.fromMessages([
  ["system", "Formuliere die Nutzerfrage als eigenständige Suchanfrage um. Nutze dabei die Gesprächshistorie als Kontext. Gib NUR die umformulierte Frage zurück."],
  new MessagesPlaceholder("chat_history"),
  ["human", "{input}"],
]);

// History-aware Retriever — berücksichtigt vorherige Turns
const historyAwareRetriever = await createHistoryAwareRetriever({
  llm: model,
  retriever,
  rephrasePrompt: contextualizePrompt,
});

// Verwendung mit Gesprächshistorie
const retrieverErgebnis = await historyAwareRetriever.invoke({
  input: "Wie funktioniert das nochmal genau?",   // Vage Folgefrage
  chat_history: [
    new HumanMessage("Erkläre TypeScript Generics."),
    new AIMessage("Generics ermöglichen typsichere Wiederverwendbarkeit..."),
  ],
});
console.log(`${retrieverErgebnis.length} relevante Chunks gefunden`);

5. Agents & Tools

KI-Agenten können eigenständig entscheiden, welche Tools sie in welcher Reihenfolge aufrufen, um ein Ziel zu erreichen. LangChain bietet fertige Agenten-Typen und eine einfache Tool-Schnittstelle zum Eigenbau.

Custom Tools mit tool() definieren

import { tool } from "@langchain/core/tools";
import { z } from "zod";

// Taschenrechner-Tool
const calculator = tool(
  async ({ ausdruck }) => {
    try {
      // Sichere Evaluierung ohne eval()
      const result = Function("return " + ausdruck.replace(/[^0-9+\-*/().]/g, ""))();
      return `Ergebnis: ${result}`;
    } catch {
      return "Ungültiger mathematischer Ausdruck.";
    }
  },
  {
    name: "calculator",
    description: "Berechnet mathematische Ausdrücke. Input: mathematischer Ausdruck als String.",
    schema: z.object({
      ausdruck: z.string().describe("Mathematischer Ausdruck, z.B. '(15 * 3) + 45 / 9'"),
    }),
  }
);

// Web-Suche Tool (simuliert)
const webSearch = tool(
  async ({ anfrage }) => {
    // In Produktion: Tavily, Bing Search API etc.
    return `Suchergebnisse für "${anfrage}": TypeScript 5.4 erschien März 2024 mit NoInfer, Array.fromAsync und weiteren Features.`;
  },
  {
    name: "web_search",
    description: "Sucht aktuelle Informationen im Internet. Verwende diese Tool für aktuelle Events und Daten.",
    schema: z.object({
      anfrage: z.string().describe("Suchanfrage"),
    }),
  }
);

// Datei-Lese-Tool
const dateiLesen = tool(
  async ({ pfad }) => {
    const fs = await import("fs/promises");
    try {
      const inhalt = await fs.readFile(pfad, "utf-8");
      return inhalt.slice(0, 2000); // Max 2000 Zeichen
    } catch {
      return `Datei nicht gefunden: ${pfad}`;
    }
  },
  {
    name: "datei_lesen",
    description: "Liest den Inhalt einer lokalen Datei. Nur für Textdateien geeignet.",
    schema: z.object({
      pfad: z.string().describe("Dateipfad relativ zum Projektverzeichnis"),
    }),
  }
);

OpenAI Functions Agent

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

// Standard-Agenten-Prompt vom LangChain Hub laden
const agentPrompt = await pull<ChatPromptTemplate>("hwchase17/openai-functions-agent");

// Tool-Liste für den Agenten
const tools = [calculator, webSearch, dateiLesen];

// Agenten erstellen
const agent = await createOpenAIFunctionsAgent({
  llm: model,
  tools,
  prompt: agentPrompt,
});

// AgentExecutor — übernimmt den Tool-Call-Loop
const executor = new AgentExecutor({
  agent,
  tools,
  verbose: true,    // Zeigt Reasoning-Schritte
  maxIterations: 8, // Verhindert Endlosschleifen
  returnIntermediateSteps: true,
});

// Agenten mit komplexer Aufgabe starten
const agentenErgebnis = await executor.invoke({
  input: "Was ist 15 * 23 + 47? Und was sind die wichtigsten neuen Features in TypeScript 5.4?",
});

console.log("Finale Antwort:", agentenErgebnis.output);
console.log("Schritte:", agentenErgebnis.intermediateSteps.length);

ReAct Agent — Reasoning & Acting

import { createReactAgent } from "langchain/agents";

// ReAct-Prompt laden (Thought → Action → Observation Loop)
const reactPrompt = await pull<ChatPromptTemplate>("hwchase17/react");

const reactAgent = await createReactAgent({
  llm: model,
  tools: [calculator, webSearch],
  prompt: reactPrompt,
});

const reactExecutor = new AgentExecutor({
  agent: reactAgent,
  tools: [calculator, webSearch],
  verbose: true,
  handleParsingErrors: true, // Bei Parsing-Fehlern retry statt crash
});

const reactErgebnis = await reactExecutor.invoke({
  input: "Suche nach TypeScript Marktanteilen 2026 und berechne, wie viele Entwickler das bei 25 Millionen JS-Devs wären wenn der Anteil 40% beträgt.",
});

console.log(reactErgebnis.output);

AGENT Agent-Typen im Vergleich

Agent-Typ	Stärken	Wann nutzen
OpenAI Functions	Zuverlässig, strukturiertes Tool-Calling	Produktions-Agenten mit definierten Tools
ReAct	Flexibel, funktioniert mit allen LLMs	Open-Source LLMs, Claude, Gemini
Plan-and-Execute	Komplexe, mehrstufige Aufgaben	Lange Aufgaben mit vielen Teilschritten

6. LangSmith Tracing & Evaluation

LangSmith ist die Observability-Plattform von LangChain. Mit wenigen Zeilen Code tracest du jeden LLM-Aufruf, misst Latenzen und Kosten und evaluierst deine Pipeline automatisch.

LangSmith einrichten

# .env — LangSmith Tracing aktivieren
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=ls__your_api_key_here
LANGCHAIN_PROJECT=typescript-rag-demo
LANGCHAIN_ENDPOINT=https://api.smith.langchain.com

import { Client } from "langsmith";
import { traceable } from "langsmith/traceable";

// LangSmith Client — braucht LANGCHAIN_API_KEY aus .env
const langsmithClient = new Client();

// @traceable — annotiert eine Funktion für LangSmith Tracing
const meineRagFunktion = traceable(
  async (frage: string): Promise<string> => {
    const antwort = await ragChain.invoke(frage);
    return antwort;
  },
  {
    name: "rag-pipeline",
    run_type: "chain",
    project_name: "typescript-rag-demo",
  }
);

// Aufruf wird automatisch in LangSmith geloggt
const ergebnis = await meineRagFunktion("Was ist TypeScript NoInfer?");
console.log(ergebnis);
console.log("✓ Trace in LangSmith sichtbar unter: https://smith.langchain.com");

Dataset erstellen und Runs evaluieren

import { evaluate } from "langsmith/evaluation";

// Test-Dataset in LangSmith erstellen
const dataset = await langsmithClient.createDataset("typescript-faq-eval", {
  description: "TypeScript Fragen für RAG-Pipeline Evaluation",
});

// Beispiele zum Dataset hinzufügen
const beispiele = [
  { inputs: { frage: "Was ist TypeScript?" }, outputs: { antwort: "TypeScript ist ein typsicheres Superset von JavaScript..." } },
  { inputs: { frage: "Was sind Generics?" }, outputs: { antwort: "Generics ermöglichen typsichere, wiederverwendbare Funktionen..." } },
  { inputs: { frage: "Was ist der Unterschied zwischen type und interface?" }, outputs: { antwort: "interface unterstützt declaration merging..." } },
];

await langsmithClient.createExamples({
  inputs: beispiele.map((b) => b.inputs),
  outputs: beispiele.map((b) => b.outputs),
  datasetId: dataset.id,
});

console.log(`Dataset erstellt mit ${beispiele.length} Beispielen`);

Automatisierte Evaluation mit Evaluatoren

import { evaluate } from "langsmith/evaluation";

// Ziel-Funktion die evaluiert werden soll
const ragFunktion = async (inputs: { frage: string }) => {
  const antwort = await ragChain.invoke(inputs.frage);
  return { antwort };
};

// LLM-basierter Evaluator für Korrektheit
const korrektheitsEvaluator = async ({
  inputs, outputs, referenceOutputs,
}: {
  inputs: { frage: string };
  outputs: { antwort: string };
  referenceOutputs: { antwort: string };
}) => {
  const bewertung = await model.invoke(
    `Ist die folgende Antwort korrekt? Antworte nur mit "ja" oder "nein".
Frage: ${inputs.frage}
Erwartete Antwort: ${referenceOutputs.antwort}
Tatsächliche Antwort: ${outputs.antwort}`
  );
  const score = bewertung.content.toString().toLowerCase().includes("ja") ? 1 : 0;
  return { key: "korrektheit", score };
};

// Evaluation gegen Dataset ausführen
const evalErgebnis = await evaluate(ragFunktion, {
  data: "typescript-faq-eval",
  evaluators: [korrektheitsEvaluator],
  experimentPrefix: "rag-v1",
  maxConcurrency: 3,
});

console.log("Evaluation abgeschlossen:");
console.log(`Korrektheit: ${evalErgebnis.results.map(r => r.evaluationResults?.results?.[0]?.score ?? 0).reduce((a, b) => a + b, 0) / evalErgebnis.results.length * 100}%`);

Latenz & Cost Tracking

import { getBufferedUsage } from "@langchain/core/utils/callbacks";

// Runs mit Latenz und Token-Usage aus LangSmith abrufen
const runs = langsmithClient.listRuns({
  projectName: "typescript-rag-demo",
  runType: "chain",
  limit: 100,
});

let totalTokens = 0;
let totalLatencyMs = 0;
let count = 0;

for await (const run of runs) {
  if (run.total_tokens) totalTokens += run.total_tokens;
  if (run.latency) totalLatencyMs += run.latency * 1000;
  count++;
}

console.log(`Analysierte Runs: ${count}`);
console.log(`Durchschnittliche Latenz: ${(totalLatencyMs / count).toFixed(0)}ms`);
console.log(`Gesamte Tokens: ${totalTokens.toLocaleString("de-DE")}`);
console.log(`Geschätzte Kosten (Claude 3.5): $${(totalTokens * 0.000003).toFixed(4)}`);

LANGSMITH Was LangSmith automatisch trackt

Alle LLM-Aufrufe mit Prompts, Antworten und Token-Counts
Tool-Aufrufe im Agenten mit Input/Output
Retriever-Aufrufe mit gefundenen Dokumenten
End-to-End-Latenz jeder Chain
Fehler und Exceptions mit vollständigem Stack-Trace

Fazit: LangChain + Claude Code = Produktionsreife KI

LangChain in TypeScript bietet 2026 alles, was du für produktionsreife KI-Anwendungen brauchst — von einfachen Chat-Interfaces über vollständige RAG-Pipelines bis zu autonomen Agenten. Die LCEL-basierte Architektur macht Chains composable und typsicher, während LangSmith komplette Observability ohne zusätzlichen Aufwand liefert.

Claude Code beschleunigt die Entwicklung erheblich: Dank Autocomplete versteht Claude Code die LangChain-Typen direkt, schlägt korrekte Imports vor und erklärt auf Nachfrage jeden Baustein der Chain.

Nächste Schritte:

LangChain installieren: npm install langchain @langchain/anthropic @langchain/core
Erstes Projekt: Einfache ChatBot-Chain mit BufferMemory
RAG-Pipeline: Eigene PDF-Dokumente indexieren
Agent bauen: Custom Tools definieren und AgentExecutor starten
LangSmith aktivieren: LANGCHAIN_TRACING_V2=true in .env

KI-Agenten-Modul im Kurs

Im Claude Code Mastery Kurs: vollständiges LangChain-Modul mit RAG-Pipelines, Agenten, Memory und LangSmith Tracing für produktionsreife KI-Anwendungen.

14 Tage kostenlos testen →