> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getnetra.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# LangChain

> Trace LangChain workflows with Netra auto-instrumentation. Monitor chains, agents, tools, and retrievers with automatic span capture for every step.

<img src="https://mintcdn.com/netra/u6ajHWd7ki_9CRWQ/images/integration-logos/ai-frameworks/langchain.png?fit=max&auto=format&n=u6ajHWd7ki_9CRWQ&q=85&s=e4265291116185b4b1f86e4c62a44a88" alt="LangChain" width="504" height="80" data-path="images/integration-logos/ai-frameworks/langchain.png" />

## Installation

Install both the Netra SDK and LangChain:

<CodeGroup>
  ```bash Python theme={null}
  pip install netra-sdk langchain langchain-openai
  ```

  ```bash Typescript theme={null}
  npm install netra-sdk langchain
  ```
</CodeGroup>

## Usage

Initialize the Netra SDK to automatically trace all LangChain operations:

<CodeGroup>
  ```python Python theme={null}
  from netra import Netra
  from langchain_openai import ChatOpenAI
  import os

  # Initialize Netra
  Netra.init(
      headers=f"x-api-key={os.environ.get('NETRA_API_KEY')}",
      trace_content=True
  )

  # Use LangChain as normal - automatically traced
  model = ChatOpenAI(temperature=0.9)
  response = model.invoke("Tell me a joke")
  ```

  ```typescript Typescript theme={null}
  import { Netra } from "netra-sdk";
  import { ChatOpenAI } from "langchain/chat_models/openai";

  async function main() {
    // Initialize Netra (must await)
    await Netra.init({
      headers: `x-api-key=${process.env.NETRA_API_KEY}`,
      traceContent: true
    });

    // Use LangChain as normal - automatically traced
    const model = new ChatOpenAI({ temperature: 0.9 });
    const response = await model.invoke("Tell me a joke");
  }

  main();
  ```
</CodeGroup>

### Chains

Trace LangChain chains with custom workflow decorators:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import workflow, span
  from langchain_openai import ChatOpenAI
  from langchain.prompts import PromptTemplate

  model = ChatOpenAI()

  @workflow()
  def summarize_chain(text: str):
      prompt = PromptTemplate.from_template(
          "Summarize this text: {text}"
      )
      chain = prompt | model
      return chain.invoke({"text": text})

  result = summarize_chain("Long article text...")
  ```

  ```typescript Typescript theme={null}
  import { workflow, span } from "netra-sdk";
  import { ChatOpenAI } from "langchain/chat_models/openai";
  import { PromptTemplate } from "langchain/prompts";

  const model = new ChatOpenAI();

  @workflow()
  async function summarizeChain(text: string) {
    const prompt = PromptTemplate.fromTemplate(
      "Summarize this text: {text}"
    );
    const chain = prompt.pipe(model);
    return await chain.invoke({ text });
  }

  const result = await summarizeChain("Long article text...");
  ```
</CodeGroup>

### Agents and Tools

Trace LangChain agents with custom span creation:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import agent, task
  from netra import SpanWrapper
  from langchain_openai import ChatOpenAI
  from langchain.agents import create_react_agent, AgentExecutor
  from langchain.tools import Tool

  model = ChatOpenAI()

  @agent()
  def run_agent(query: str):
      span = SpanWrapper("agent-execution").start()
      
      try:
          agent_executor = create_react_agent(
              llm=model,
              tools=[calculator_tool]
          )
          
          result = agent_executor.invoke({"input": query})
          span.end()
          return result
      except Exception as e:
          span.set_attribute("error", str(e))
          span.end()
          raise
  ```

  ```typescript Typescript theme={null}
  import { agent, task, SpanWrapper } from "netra-sdk";
  import { ChatOpenAI } from "langchain/chat_models/openai";
  import { Calculator } from "langchain/tools/calculator";
  import { createReactAgent, AgentExecutor } from "langchain/agents";

  const model = new ChatOpenAI();
  const tools = [new Calculator()];

  @agent()
  async function runAgent(query: string) {
    const span = new SpanWrapper("agent-execution").start();
    
    try {
      const agentExecutor = await createReactAgent({
        llm: model,
        tools
      });
      
      const result = await agentExecutor.invoke({ input: query });
      span.end();
      return result;
    } catch (error) {
      span.setAttribute("error", String(error));
      span.end();
      throw error;
    }
  }
  ```
</CodeGroup>

### Streaming Responses

The SDK automatically captures streaming outputs from LangChain:

<CodeGroup>
  ```python Python theme={null}
  from netra.decorators import task

  @task()
  def stream_response(query: str):
      model = ChatOpenAI(streaming=True)
      
      for chunk in model.stream(query):
          print(chunk.content, end="", flush=True)
  ```

  ```typescript Typescript theme={null}
  import { task } from "netra-sdk";

  @task()
  async function streamResponse(query: string) {
    const model = new ChatOpenAI({ streaming: true });
    
    for await (const chunk of await model.stream(query)) {
      process.stdout.write(chunk.content);
    }
  }
  ```
</CodeGroup>

### Selective Instrumentation

Control which integrations are enabled:

<CodeGroup>
  ```python Python theme={null}
  from netra import Netra
  from netra.instrumentation.instruments import InstrumentSet

  # Only enable specific instruments
  Netra.init(
      headers=f"x-api-key={os.environ.get('NETRA_API_KEY')}",
      instruments={InstrumentSet.OPENAI}
  )
  ```

  ```typescript Typescript theme={null}
  import { Netra, NetraInstruments } from "netra-sdk";

  // Only enable specific instruments
  await Netra.init({
    headers: `x-api-key=${process.env.NETRA_API_KEY}`,
    instruments: new Set([NetraInstruments.OPENAI])
  });
  ```
</CodeGroup>

## Next Steps

* [Quick Start Guide](https://docs.getnetra.ai/quick-start/python) - Complete setup and configuration
* [Auto Instrumentation](https://docs.getnetra.ai/tracing/auto-instrumentation) - Automatic tracing for supported libraries
* [Decorators](https://docs.getnetra.ai/tracing/decorators) - Add custom tracing with `@workflow`, `@agent`, and `@task` decorators
* [Session Tracking](https://docs.getnetra.ai/tracing/session) - Track user sessions and conversations
* [LangChain Documentation](https://python.langchain.com/docs/get_started/quickstart) - Official LangChain quickstart guide