LangChain Integration

import * as Sentry from '@sentry/node';

Sentry.init({
  dsn: 'your-dsn',
  // langChainIntegration is included by default
});

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

const model = new ChatOpenAI({
  modelName: 'gpt-4',
});

// Automatically instrumented
const response = await model.invoke('What is the capital of France?');

Sentry.init({
  dsn: 'your-dsn',
  sendDefaultPii: false, // Default: no inputs/outputs
});

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

const openai = new ChatOpenAI();
const anthropic = new ChatAnthropic();

// Both automatically tracked
await openai.invoke('Hello!');
await anthropic.invoke('Hello!');

import { ChatOpenAI } from '@langchain/openai';
import { PromptTemplate } from '@langchain/core/prompts';

const model = new ChatOpenAI();
const prompt = PromptTemplate.fromTemplate(
  'Tell me a joke about {topic}'
);

const chain = prompt.pipe(model);

// Chain execution tracked
const response = await chain.invoke({ topic: 'programming' });

import { DynamicTool } from '@langchain/core/tools';

const weatherTool = new DynamicTool({
  name: 'get_weather',
  description: 'Get the current weather',
  func: async (location) => {
    return `Weather in ${location}: Sunny, 72°F`;
  },
});

// Tool execution tracked
await weatherTool.invoke({ location: 'San Francisco' });

import * as Sentry from '@sentry/node';
import { ChatOpenAI } from '@langchain/openai';

const sentryHandler = Sentry.createLangChainCallbackHandler({
  recordInputs: true,
  recordOutputs: true,
});

const model = new ChatOpenAI();
const response = await model.invoke(
  'What is AI?',
  { callbacks: [sentryHandler, myOtherCallback] }
);

import * as Sentry from '@sentry/node';
import { ChatOpenAI } from '@langchain/openai';
import { PromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const model = new ChatOpenAI({ modelName: 'gpt-4' });

const prompt = PromptTemplate.fromTemplate(`
Answer the following question based on the context:

Context: {context}

Question: {question}

Answer:
`);

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

// Automatically tracked in Sentry
const answer = await chain.invoke({
  context: 'Paris is the capital of France.',
  question: 'What is the capital of France?',
});

import { ChatOpenAI } from '@langchain/openai';
import { OpenAIEmbeddings } from '@langchain/openai';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';
import { createRetrievalChain } from 'langchain/chains/retrieval';
import { createStuffDocumentsChain } from 'langchain/chains/combine_documents';

const embeddings = new OpenAIEmbeddings();
const vectorStore = await MemoryVectorStore.fromTexts(
  ['Paris is the capital of France', 'Berlin is the capital of Germany'],
  [{ source: 'doc1' }, { source: 'doc2' }],
  embeddings
);

const model = new ChatOpenAI();
const combineDocsChain = await createStuffDocumentsChain({ llm: model });
const retrievalChain = await createRetrievalChain({
  retriever: vectorStore.asRetriever(),
  combineDocsChain,
});

// Full RAG pipeline tracked
const response = await retrievalChain.invoke({
  input: 'What is the capital of France?',
});

import { ChatOpenAI } from '@langchain/openai';
import { DynamicTool } from '@langchain/core/tools';
import { createToolCallingAgent, AgentExecutor } from 'langchain/agents';
import { ChatPromptTemplate } from '@langchain/core/prompts';

const model = new ChatOpenAI({
  modelName: 'gpt-4',
  temperature: 0,
});

const tools = [
  new DynamicTool({
    name: 'calculator',
    description: 'Performs basic math operations',
    func: async (input) => {
      return eval(input).toString();
    },
  }),
  new DynamicTool({
    name: 'weather',
    description: 'Gets current weather',
    func: async (location) => {
      return `Weather in ${location}: Sunny`;
    },
  }),
];

const prompt = ChatPromptTemplate.fromMessages([
  ['system', 'You are a helpful assistant'],
  ['human', '{input}'],
  ['placeholder', '{agent_scratchpad}'],
]);

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

// Agent execution and tool calls tracked
const result = await executor.invoke({
  input: 'What is 25 * 4 and what is the weather in Paris?',
});

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

const model = new ChatOpenAI({
  streaming: true,
});

// Streaming tracked with final response
const stream = await model.stream('Tell me a story');

for await (const chunk of stream) {
  process.stdout.write(chunk.content);
}

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

// Only LangChain spans are created (no OpenAI/Anthropic duplicates)
const openai = new ChatOpenAI();
await openai.invoke('Hello');

const anthropic = new ChatAnthropic();
await anthropic.invoke('Hello');

import OpenAI from 'openai';
import { ChatOpenAI } from '@langchain/openai';

const openai = new OpenAI();
const langchainModel = new ChatOpenAI();

// Creates OpenAI span
await openai.chat.completions.create({...});

// Creates LangChain span
await langchainModel.invoke('Hello');

Transaction: POST /api/chat
├─ langchain.chain.start
│  ├─ langchain.llm.start (OpenAI GPT-4)
│  │  └─ Duration: 2.1s
│  ├─ langchain.tool.start (calculator)
│  │  └─ Duration: 15ms
│  └─ Duration: 2.5s
└─ Total: 2.5s

Sentry.init({
  dsn: 'your-dsn',
  sendDefaultPii: true,
  
  beforeSendSpan(span) {
    // Remove sensitive data from LangChain spans
    if (span.op?.startsWith('langchain')) {
      const attributes = span.attributes || {};
      for (const key in attributes) {
        if (key.includes('input') || key.includes('prompt')) {
          attributes[key] = '[Filtered]';
        }
      }
    }
    return span;
  },
});

Sentry.init({
  dsn: 'your-dsn',
  tracesSampleRate: 1.0,
});

const sentryHandler = Sentry.createLangChainCallbackHandler();
const myHandler = new MyCustomHandler();

await model.invoke('Hello', {
  callbacks: [sentryHandler, myHandler],
});