LangChain Integration

from langchain.chains import ConversationalRetrievalChain
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import Pinecone
from agenticants.integrations.langchain import AgenticAntsCallbackHandler
 
# Set up components
llm = ChatOpenAI()
vectorstore = Pinecone.from_existing_index('my-index')
 
# Create chain with AgenticAnts callback
handler = AgenticAntsCallbackHandler(ants, trace_name='rag-chain')
 
chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=vectorstore.as_retriever(),
    callbacks=[handler]
)
 
# Run chain - fully traced!
result = chain({
    "question": "What are the product features?",
    "chat_history": []
})
 
# AgenticAnts captures:
# - Question asked
# - Documents retrieved
# - LLM prompt and response
# - Total tokens and cost
# - Execution time per step

import { AgentExecutor, ZeroShotAgent } from 'langchain/agents'
import { ChatOpenAI } from 'langchain/chat_models/openai'
import { SerpAPI } from 'langchain/tools'
import { AgenticAntsCallbackHandler } from '@agenticants/langchain'
 
const llm = new ChatOpenAI({ temperature: 0 })
const tools = [new SerpAPI()]
 
const handler = new AgenticAntsCallbackHandler(ants, {
  traceName: 'research-agent',
  metadata: { agentType: 'zero-shot' }
})
 
const agent = ZeroShotAgent.fromLLMAndTools(llm, tools)
const executor = new AgentExecutor({
  agent,
  tools,
  callbacks: [handler]
})
 
const result = await executor.call({
  input: "What's the weather in San Francisco?"
})
 
// AgenticAnts tracks:
// - Agent planning steps
// - Tool calls (SerpAPI)
// - LLM reasoning
// - Final answer

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
 
memory = ConversationBufferMemory()
 
chain = ConversationChain(
    llm=llm,
    memory=memory,
    callbacks=[handler]
)
 
# Each conversation turn is traced
chain.predict(input="Hi, I'm looking for a laptop")
chain.predict(input="What are some good options under $1000?")
chain.predict(input="Tell me more about the first one")
 
# AgenticAnts shows:
# - Full conversation history
# - Memory usage
# - Context provided to LLM

from langgraph.graph import StateGraph
from agenticants.integrations.langchain import AgenticAntsCallbackHandler
 
# Define your graph
workflow = StateGraph(AgentState)
 
# Add nodes
workflow.add_node("researcher", research_node)
workflow.add_node("writer", write_node)
workflow.add_node("editor", edit_node)
 
# Add edges
workflow.add_edge("researcher", "writer")
workflow.add_edge("writer", "editor")
 
# Compile with AgenticAnts tracing
app = workflow.compile()
 
handler = AgenticAntsCallbackHandler(ants, trace_name='content-pipeline')
 
# Run with tracing
result = app.invoke(
    {"topic": "AI agents"},
    config={"callbacks": [handler]}
)
 
# AgenticAnts visualizes:
# - Complete graph execution
# - Each node's input/output
# - State transitions
# - Timing per node

{
  type: 'llm',
  model: 'gpt-4',
  prompt: 'What is AI?',
  completion: 'AI is...',
  tokens: {
    prompt: 15,
    completion: 150,
    total: 165
  },
  cost: 0.00495,
  latency: 1250,  // ms
  temperature: 0.7,
  maxTokens: 500
}

{
    'type': 'chain',
    'chain_type': 'ConversationalRetrievalChain',
    'input': 'What are the features?',
    'output': 'The features include...',
    'steps': [
        {'name': 'retrieval', 'docs': 5, 'duration': 200},
        {'name': 'llm', 'tokens': 350, 'duration': 1500}
    ]
}

{
  type: 'tool',
  name: 'search',
  input: 'weather in SF',
  output: '68°F and sunny',
  duration: 450  // ms
}

handler = AgenticAntsCallbackHandler(
    ants,
    trace_name='customer-support-bot',  # Descriptive name
    metadata={
        'channel': 'web',
        'version': '2.1.0'
    }
)

const handler = new AgenticAntsCallbackHandler(ants, {
  metadata: {
    userId: 'user_123',
    sessionId: 'session_abc',
    customerTier: 'enterprise',
    feature: 'qa-bot'
  }
})

try:
    result = chain.run(query, callbacks=[handler])
except Exception as error:
    # Error is automatically captured by AgenticAnts
    logger.error(f"Chain failed: {error}")

// Only trace in production for high-value requests
const shouldTrace = (request) => {
  if (process.env.NODE_ENV !== 'production') return false
  if (request.userTier === 'enterprise') return true
  return Math.random() < 0.1
}
 
if (shouldTrace(request)) {
  llm.callbacks = [new AgenticAntsCallbackHandler(ants)]
}

from langchain.chains import RetrievalQA
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
 
# Load and process documents
loader = TextLoader('docs.txt')
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000)
docs = text_splitter.split_documents(documents)
 
# Create vector store
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
 
# Create QA chain with tracing
handler = AgenticAntsCallbackHandler(ants, trace_name='doc-qa')
 
qa = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(),
    retriever=vectorstore.as_retriever(),
    callbacks=[handler]
)
 
# Query with full observability
answer = qa.run("What is mentioned about pricing?")

import { AgentExecutor } from 'langchain/agents'
 
const researcher = new AgentExecutor({
  agent: researchAgent,
  tools: researchTools,
  callbacks: [new AgenticAntsCallbackHandler(ants, {
    traceName: 'researcher-agent'
  })]
})
 
const writer = new AgentExecutor({
  agent: writerAgent,
  tools: writerTools,
  callbacks: [new AgenticAntsCallbackHandler(ants, {
    traceName: 'writer-agent'
  })]
})
 
// Coordinate agents
const research = await researcher.call({ input: topic })
const article = await writer.call({ 
  input: `Write about: ${research.output}` 
})
 
// AgenticAnts shows both agents' work

# Make sure callbacks are passed correctly
chain.run(query, callbacks=[handler])  #  Correct
 
# Not this
chain.callbacks = [handler]
chain.run(query)  #  May not work

// Ensure you're using a model that reports usage
const llm = new ChatOpenAI({
  modelName: 'gpt-4',  //  Reports usage
  callbacks: [handler]
})

# Use sampling to reduce costs
import random
 
if random.random() < 0.1:  # 10% sampling
    callbacks = [handler]
else:
    callbacks = []
 
chain.run(query, callbacks=callbacks)