Repairyourtech Cfsa Antigravity Langchain

LangChain (TypeScript)

Status: Production Ready Last Updated: 2026-02-16 Packages: langchain@0.3.x, @langchain/core@0.3.x, @langchain/openai, @langchain/anthropic, @langchain/community

Installation

# Core + OpenAI provider
pnpm add langchain @langchain/core @langchain/openai

# Additional providers as needed
pnpm add @langchain/anthropic    # Anthropic Claude
pnpm add @langchain/community    # Community integrations (Ollama, vector stores, etc.)

Core Concepts

LangChain organizes LLM applications into composable primitives:

Chat Models

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

// OpenAI
const gpt4o = new ChatOpenAI({
  model: "gpt-4o",
  temperature: 0.7,
  maxTokens: 1000,
  apiKey: process.env.OPENAI_API_KEY,
});

// Anthropic
const claude = new ChatAnthropic({
  model: "claude-sonnet-4-20250514",
  temperature: 0.7,
  maxTokens: 1000,
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// Basic invocation
const response = await gpt4o.invoke("What is the capital of France?");
console.log(response.content); // "The capital of France is Paris."

// With message types
import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";

const response = await gpt4o.invoke([
  new SystemMessage("You are a helpful assistant."),
  new HumanMessage("Explain quantum computing briefly."),
]);

LangChain Expression Language (LCEL)

LCEL is the composition primitive. Components are piped together with .pipe().

Basic Chain

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant that translates {input_language} to {output_language}."],
  ["human", "{input}"],
]);

const model = new ChatOpenAI({ model: "gpt-4o-mini" });
const parser = new StringOutputParser();

// Pipe: prompt -> model -> parser
const chain = prompt.pipe(model).pipe(parser);

const result = await chain.invoke({
  input_language: "English",
  output_language: "French",
  input: "Hello, how are you?",
});
// result: "Bonjour, comment allez-vous ?"

RunnableSequence (Explicit)

import { RunnableSequence, RunnablePassthrough } from "@langchain/core/runnables";

const chain = RunnableSequence.from([
  {
    context: retriever, // Fetches relevant docs
    question: new RunnablePassthrough(), // Passes input through
  },
  prompt,
  model,
  parser,
]);

Parallel Execution (RunnableParallel)

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

const analysisChain = RunnableParallel.from({
  summary: summaryChain,
  sentiment: sentimentChain,
  keywords: keywordsChain,
});

const result = await analysisChain.invoke({ text: "Product review text..." });
// { summary: "...", sentiment: "positive", keywords: ["quality", "price"] }

Branching (RunnableRouter)

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

const routerChain = RunnableBranch.from([
  [(input) => input.topic === "technical", technicalChain],
  [(input) => input.topic === "billing", billingChain],
  generalChain, // Default
]);

Prompt Templates

import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";

// Simple template
const simple = ChatPromptTemplate.fromMessages([
  ["system", "You are a {role} assistant."],
  ["human", "{question}"],
]);

// With conversation history
const withHistory = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant."],
  new MessagesPlaceholder("chat_history"), // Injects previous messages
  ["human", "{input}"],
]);

// Usage
await withHistory.invoke({
  chat_history: [
    new HumanMessage("Hi"),
    new AIMessage("Hello! How can I help?"),
  ],
  input: "What did I just say?",
});

Output Parsers

String Parser

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

const chain = prompt.pipe(model).pipe(new StringOutputParser());

Structured Output with Zod

import { z } from "zod";

const ReviewSchema = z.object({
  sentiment: z.enum(["positive", "negative", "neutral"]),
  confidence: z.number().min(0).max(1),
  summary: z.string(),
  key_points: z.array(z.string()),
});

// Method 1: withStructuredOutput (preferred — uses tool calling under the hood)
const structuredModel = model.withStructuredOutput(ReviewSchema);
const result = await structuredModel.invoke("Review: This product is amazing, great quality!");
// result: { sentiment: "positive", confidence: 0.95, summary: "...", key_points: [...] }

// Method 2: StructuredOutputParser (older approach, uses prompt instructions)
import { StructuredOutputParser } from "@langchain/core/output_parsers";

const parser = StructuredOutputParser.fromZodSchema(ReviewSchema);
const formatInstructions = parser.getFormatInstructions();
// Include formatInstructions in prompt, then parse response

JSON Output Parser

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

const parser = new JsonOutputParser();
const chain = prompt.pipe(model).pipe(parser);

Retrieval (RAG)

Document Loading

import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { WebLoader } from "@langchain/community/document_loaders/web/cheerio";

// Load PDF
const pdfLoader = new PDFLoader("./docs/manual.pdf");
const pdfDocs = await pdfLoader.load();

// Split into chunks
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
  separators: ["\n\n", "\n", ". ", " ", ""],
});
const chunks = await splitter.splitDocuments(pdfDocs);

Vector Store

import { OpenAIEmbeddings } from "@langchain/openai";
import { MemoryVectorStore } from "langchain/vectorstores/memory";
// For production: use Pinecone, Supabase, Chroma, etc.

const embeddings = new OpenAIEmbeddings({ model: "text-embedding-3-small" });

// Create store from documents
const vectorStore = await MemoryVectorStore.fromDocuments(chunks, embeddings);

// Create retriever
const retriever = vectorStore.asRetriever({
  k: 4, // Number of documents to retrieve
  searchType: "similarity", // or "mmr" for diversity
});

// Retrieve relevant docs
const relevantDocs = await retriever.invoke("How do I reset my password?");

RAG Chain

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

const ragPrompt = ChatPromptTemplate.fromMessages([
  [
    "system",
    `Answer the question based only on the following context. If the context
doesn't contain the answer, say "I don't have enough information to answer that."

Context: {context}`,
  ],
  ["human", "{question}"],
]);

const ragChain = RunnableSequence.from([
  {
    context: retriever.pipe(formatDocumentsAsString),
    question: new RunnablePassthrough(),
  },
  ragPrompt,
  model,
  new StringOutputParser(),
]);

const answer = await ragChain.invoke("How do I reset my password?");

Agents

Tool-Calling Agent (Recommended)

import { ChatOpenAI } from "@langchain/openai";
import { createToolCallingAgent, AgentExecutor } from "langchain/agents";
import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
import { DynamicStructuredTool } from "@langchain/core/tools";
import { z } from "zod";

// Define tools
const weatherTool = new DynamicStructuredTool({
  name: "get_weather",
  description: "Get current weather for a city",
  schema: z.object({
    city: z.string().describe("City name"),
    unit: z.enum(["celsius", "fahrenheit"]).default("celsius"),
  }),
  func: async ({ city, unit }) => {
    const data = await fetchWeather(city, unit);
    return JSON.stringify(data);
  },
});

const searchTool = new DynamicStructuredTool({
  name: "search_docs",
  description: "Search internal documentation",
  schema: z.object({
    query: z.string().describe("Search query"),
  }),
  func: async ({ query }) => {
    const results = await searchDocumentation(query);
    return JSON.stringify(results);
  },
});

// Create agent
const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant with access to tools."],
  new MessagesPlaceholder("chat_history"),
  ["human", "{input}"],
  new MessagesPlaceholder("agent_scratchpad"),
]);

const model = new ChatOpenAI({ model: "gpt-4o", temperature: 0 });
const tools = [weatherTool, searchTool];

const agent = createToolCallingAgent({ llm: model, tools, prompt });
const executor = new AgentExecutor({ agent, tools, verbose: true });

const result = await executor.invoke({
  input: "What's the weather in Tokyo?",
  chat_history: [],
});

Memory

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

// Buffer memory — stores all messages
const memory = new BufferMemory({
  memoryKey: "chat_history",
  returnMessages: true, // Return as Message objects (not string)
});

// With LCEL — manage history manually (recommended)
const messages: BaseMessage[] = [];

async function chat(userInput: string) {
  messages.push(new HumanMessage(userInput));

  const response = await chain.invoke({
    chat_history: messages,
    input: userInput,
  });

  messages.push(new AIMessage(response));
  return response;
}

Summary Memory (For Long Conversations)

import { ConversationSummaryMemory } from "langchain/memory";

const memory = new ConversationSummaryMemory({
  llm: new ChatOpenAI({ model: "gpt-4o-mini" }),
  memoryKey: "chat_history",
  returnMessages: true,
});
// Summarizes older messages to stay within token limits

Callbacks and Streaming

// Streaming with LCEL
const stream = await chain.stream({ question: "Explain gravity" });

for await (const chunk of stream) {
  process.stdout.write(chunk); // Each chunk is a string token
}

// Callbacks for observability
import { BaseCallbackHandler } from "@langchain/core/callbacks/base";

class LoggingHandler extends BaseCallbackHandler {
  name = "logging";

  async handleLLMStart(llm: any, prompts: string[]) {
    console.log("LLM started:", prompts.length, "prompts");
  }

  async handleLLMEnd(output: any) {
    console.log("LLM finished. Tokens:", output.llmOutput?.tokenUsage);
  }

  async handleToolStart(tool: any, input: string) {
    console.log(`Tool ${tool.name} called with:`, input);
  }
}

const result = await chain.invoke(input, {
  callbacks: [new LoggingHandler()],
});

LangSmith Tracing

# Environment variables
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY="ls__..."
LANGCHAIN_PROJECT="my-project"

When env vars are set, all LangChain calls are automatically traced. No code changes needed.

// Custom run metadata
const result = await chain.invoke(input, {
  runName: "customer-support-query",
  metadata: { userId: "123", sessionId: "abc" },
  tags: ["production", "support"],
});

Common Patterns

Conversational RAG

// Rephrase question using chat history, then retrieve, then answer
const rephrasePrompt = ChatPromptTemplate.fromMessages([
  ["system", "Given the chat history, rephrase the follow-up question as a standalone question."],
  new MessagesPlaceholder("chat_history"),
  ["human", "{input}"],
]);

const rephraseChain = rephrasePrompt.pipe(model).pipe(new StringOutputParser());

const conversationalRagChain = RunnableSequence.from([
  {
    context: rephraseChain.pipe(retriever).pipe(formatDocumentsAsString),
    question: rephraseChain,
    chat_history: (input: any) => input.chat_history,
  },
  ragPrompt,
  model,
  new StringOutputParser(),
]);

Fallback Chains

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

const primary = new ChatOpenAI({ model: "gpt-4o" });
const fallback = new ChatAnthropic({ model: "claude-sonnet-4-20250514" });

// If primary fails, automatically try fallback
const resilientModel = primary.withFallbacks({ fallbacks: [fallback] });

Anti-Patterns

Last verified: 2026-02-16 | Skill version: 1.0.0

Source: RepairYourTech/cfsa-antigravity — distributed by TomeVault.