LangGraph Traces

import { agentSpan, setup } from "@inference/tracing";
import * as CallbackManagerModule from "@langchain/core/callbacks/manager";
import { Annotation, END, START, StateGraph } from "@langchain/langgraph";

const tracing = await setup({
  serviceName: "counter-graph",
  modules: { langchainCallbacksManager: CallbackManagerModule },
});

const State = Annotation.Root({
  count: Annotation<number>({
    reducer: (_left, right) => right,
    default: () => 0,
  }),
});

const graph = new StateGraph(State)
  .addNode("increment", (state) => ({ count: state.count + 1 }))
  .addNode("double", (state) => ({ count: state.count * 2 }))
  .addEdge(START, "increment")
  .addEdge("increment", "double")
  .addEdge("double", END)
  .compile();

const result = await agentSpan(
  {
    agentId: "counter-graph-agent",
    agentName: "Counter Graph Agent",
    spanName: "counter-graph.run",
    sessionId: "conversation-counter-1",
    role: "workflow",
    system: "langgraph",
  },
  async (span) => {
    const input = { count: 1 };
    span.setInput(input);
    const output = await graph.invoke(input);
    span.setOutput(output);
    return output;
  },
);
console.log(result);

await tracing.shutdown();

from inference_catalyst_tracing import agent_span, setup
from langgraph.graph import END, START, StateGraph
from typing_extensions import TypedDict

class GraphState(TypedDict):
    count: int

tracing = setup(service_name="counter-graph")

def increment(state: GraphState) -> GraphState:
    return {"count": state["count"] + 1}

def double(state: GraphState) -> GraphState:
    return {"count": state["count"] * 2}

builder = StateGraph(GraphState)
builder.add_node("increment", increment)
builder.add_node("double", double)
builder.add_edge(START, "increment")
builder.add_edge("increment", "double")
builder.add_edge("double", END)

graph = builder.compile()
with agent_span(
    tracing.tracer,
    agent_id="counter-graph-agent",
    agent_name="Counter Graph Agent",
    span_name="counter-graph.run",
    session_id="conversation-counter-1",
    agent_role="workflow",
    system="langgraph",
) as span:
    input_state = {"count": 1}
    span.set_input(input_state)
    result = graph.invoke(input_state)
    span.set_output(result)
    print(result)

tracing.shutdown()