LangChain

Valiqor provides the deepest integration with LangChain, automatically tracing chat models, chains, tools, retrievers, and LangGraph nodes. RAG pipelines get dedicated retrieval spans with document scores and relevance data.

Install

pip install valiqor[langchain]

This installs valiqor plus langchain>=0.1.0 and langchain-core>=0.1.0.

Zero-Config (Recommended)

Add a single import at the top of your app — all LangChain components are automatically traced:

import valiqor.auto  # ← Add this line

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(model="gpt-4o")
response = llm.invoke([HumanMessage(content="Explain quantum computing")])
print(response.content)

Every LLM call, chain invocation, tool execution, and retrieval is traced.

Selective Instrumentation

If you only want LangChain tracing:

from valiqor.trace import langchain_autolog

langchain_autolog()

# Or using the namespace-style API:
from valiqor.trace import LangChain
LangChain.autolog()

What Gets Instrumented

LangChain instrumentation covers 5 subsystems:

Chat Models

invoke(), ainvoke(), stream(), astream() on any BaseChatModel subclass — captures model name, vendor, tokens, cost, and messages.

Chains

invoke() and ainvoke() on Runnable chains — captures the full LCEL pipeline execution.

Tools

invoke(), ainvoke(), run(), arun() on BaseTool — captures tool name, arguments, and results.

Retrievers

get_relevant_documents() and aget_relevant_documents() on BaseRetriever — captures documents, scores, and retrieval metadata.

LangGraph

LangGraph is also instrumented automatically:

Graph execution: invoke() and ainvoke() on compiled graphs
Node execution: Individual node functions are wrapped and traced
State tracking: Graph state transitions are captured

RAG Pipeline Tracing

When using retrievers, Valiqor captures rich RAG-specific data automatically:

import valiqor.auto
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

# Build RAG chain
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(
    ["Paris is the capital of France", "Berlin is the capital of Germany"],
    embeddings
)
retriever = vectorstore.as_retriever()
llm = ChatOpenAI(model="gpt-4o")

prompt = ChatPromptTemplate.from_template(
    "Answer based on context: {context}\n\nQuestion: {question}"
)

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
)

# RAG retrieval is automatically traced with document scores
response = chain.invoke("What is the capital of France?")

Each retrieval span captures:

Field	Description
Documents	Retrieved documents with content snippets
Scores	Relevance scores per document
Metadata	Document metadata (source, page, etc.)
Embedding model	Model used for embeddings (when available)
Latency	Retrieval time in milliseconds
Top-k	Number of documents retrieved

Async Support

All LangChain async methods are traced automatically:

import valiqor.auto
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(model="gpt-4o")

async def main():
    response = await llm.ainvoke([HumanMessage(content="Hello!")])
    print(response.content)

Streaming

LangChain streaming is supported — stream() and astream() calls are traced:

import valiqor.auto
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

llm = ChatOpenAI(model="gpt-4o")

for chunk in llm.stream([HumanMessage(content="Tell me a story")]):
    print(chunk.content, end="")

Custom Retriever Detection

If you have custom retrieval tools that Valiqor doesn’t detect automatically, you can register them:

from valiqor.trace import configure_retriever_detection, autolog

configure_retriever_detection(
    name_patterns=["my_search_tool", "doc_finder"],
    class_patterns=["MyCustomRetriever"],
    module_patterns=["my_app.search"]
)

autolog(["langchain"])

What Gets Captured

Chat Model Spans

Field	Description
`model`	Model name
`vendor`	Provider (auto-detected from class name)
`prompt_tokens`	Input tokens
`completion_tokens`	Output tokens
`total_tokens`	Combined tokens
`cost`	Estimated cost in USD
`messages`	Full message history
`tool_calls`	Tool call arguments and results

Tool Spans

Field	Description
`tool_name`	Name of the tool
`arguments`	Input arguments
`result`	Tool output
`duration_ms`	Execution time

With Workflows

Group LangChain operations into a named trace:

import valiqor.auto
from valiqor.trace import trace_workflow
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

with trace_workflow("customer-support-agent"):
    # All LangChain calls within this block are grouped
    response = llm.invoke("How can I help you?")

Disabling

from valiqor.trace import disable_autolog

disable_autolog("langchain")    # Disable LangChain only
disable_autolog()               # Disable all providers

Start Here

Core Workflows

Concepts

Integrations

Resources

Install

Zero-Config (Recommended)

Selective Instrumentation

What Gets Instrumented

Chat Models

Chains

Tools

Retrievers

LangGraph

RAG Pipeline Tracing

Async Support

Streaming

Custom Retriever Detection

What Gets Captured

Chat Model Spans

Tool Spans

With Workflows

Disabling

Next Steps

Tracing Guide

Traces & Spans

​Install

​Zero-Config (Recommended)

​Selective Instrumentation

​What Gets Instrumented

Chat Models

Chains

Tools

Retrievers

​LangGraph

​RAG Pipeline Tracing

​Async Support

​Streaming

​Custom Retriever Detection

​What Gets Captured

​Chat Model Spans

​Tool Spans

​With Workflows

​Disabling

​Next Steps

Tracing Guide

Traces & Spans

Install

Zero-Config (Recommended)

Selective Instrumentation

What Gets Instrumented

LangGraph

RAG Pipeline Tracing

Async Support

Streaming

Custom Retriever Detection

What Gets Captured

Chat Model Spans

Tool Spans

With Workflows

Disabling

Next Steps