LangChain

pip install netra-sdk langchain langchain-openai

npm install netra-sdk langchain

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")

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();

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...")

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...");

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

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;
  }
}

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)

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);
  }
}

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}
)

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])
});