Framework Setup

Per-framework setup guide — what auto-instruments, what needs a decorator, and why.

LangChain

LangChain is fully auto-instrumented. No code changes to your agent logic.

pip install spineforge langchain langchain-openai

import spineforge
from langchain.agents import AgentExecutor
from langchain_openai import ChatOpenAI

spine = spineforge.init(agent_name="langchain-agent")

llm = ChatOpenAI(model="gpt-4o")
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

with spine.run(input=user_query) as run:
    result = executor.invoke({"input": user_query})
    run.set_output(result["output"])

LangGraph

pip install spineforge langgraph langchain-openai

import spineforge

spine = spineforge.init(agent_name="langgraph-agent")

# Build your graph normally
graph = build_your_langgraph(...)

with spine.run(input=user_query) as run:
    result = graph.invoke({"messages": [("user", user_query)]})
    run.set_output(result["messages"][-1].content)

LangGraph builds on LangChain's callback system — the same instrumentor captures all LLM and tool spans.

CrewAI

pip install spineforge crewai

import spineforge
from crewai import Crew, Agent, Task

spine = spineforge.init(agent_name="crewai-agent")

researcher = Agent(role="Researcher", ...)
task = Task(description=user_query, agent=researcher)
crew = Crew(agents=[researcher], tasks=[task])

with spine.run(input=user_query) as run:
    result = crew.kickoff()
    run.set_output(str(result))

AutoGen

pip install spineforge pyautogen

import spineforge
import autogen

spine = spineforge.init(agent_name="autogen-agent")

assistant = autogen.AssistantAgent("assistant", llm_config=config)
user_proxy = autogen.UserProxyAgent("user_proxy", ...)

with spine.run(input=user_query) as run:
    user_proxy.initiate_chat(assistant, message=user_query)
    run.set_output("conversation complete")

Raw OpenAI SDK

The Groq/OpenAI SDK-level instrumentor auto-captures chat.completions.create() calls. For your own tool functions, add @track_tool:

pip install spineforge openai

import spineforge
from spineforge import track_tool
from openai import OpenAI

spine = spineforge.init(agent_name="raw-sdk-agent")

@track_tool
def search(query: str) -> str:
    return fetch_search_results(query)

@track_tool
def call_api(endpoint: str) -> dict:
    return requests.get(endpoint).json()

with spine.run(input=user_query) as run:
    client = OpenAI(api_key=spine.lease_credential("openai-api-key"))
    # LLM calls auto-captured
    resp = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": user_query}]
    )
    # Tool calls captured by @track_tool
    search_result = search(resp.choices[0].message.content)
    run.set_output(search_result)

Adding a new framework (for contributors)

To add support for a new framework:

1. Install the instrumentor package:

   pip install opentelemetry-instrumentation-<framework>

2. Activate it in instrumentation.py:

   try:
       from opentelemetry.instrumentation.crewai import CrewAIInstrumentor
       CrewAIInstrumentor().instrument(tracer_provider=provider)
   except ImportError:
       pass  # Framework not installed — skip silently

3. Add span classification in span_processor.py: Add a condition in _classify_and_build() to detect framework-specific span attributes.

Next steps

• Sinks — configure where telemetry goes
• Telemetry — how the OTel pipeline works end-to-end