How to query available tools for trace/observation?

[ValeKnappich]

Describe your question

In the observation view in the Langfuse UI, I can see the available tools that are provided to the LLM. When querying data from the API (currently via python sdk), I don't see this information in the trace or observation objects (to be clear, I see tool calls but not the list of available tools and their schemas). Is there any way to access this information via API?

Langfuse Cloud or Self-Hosted?

Self-Hosted

If Self-Hosted

v3.161.00

If Langfuse Cloud

No response

SDK and integration versions

python sdk 4.7.1

Pre-Submission Checklist

• I have checked for existing issues/discussions and consulted Langfuse AI.

[barry166]

I don't think the public observation API / Python SDK currently exposes full available-tool schemas as first-class fields.

From the current code path, v1 transformDbToApiObservation explicitly excludes toolDefinitions, toolCalls, and toolCallNames. The v2 observations API field groups are also intentionally narrower than the full export/internal surface: public groups include io, metadata, model, etc., while the full set adds tools (tool_definitions, tool_calls, tool_call_names). The UI/table can show "Available Tools" because it reads the events/observations tool_definitions column internally, but that does not mean the same object is returned by get_observation.

Practical options:

• if you only need names/counts in Langfuse UI/querying, use the built-in available/called tool fields there;
• if you need schemas via SDK/API, also write the tool definitions into metadata or input when logging the generation;
• on self-hosted, query/export the events data with the tools field group / tool_definitions directly.

So for Python SDK today, I would not expect trace or observation objects to contain the full available-tools schema unless you put it in a public field yourself.

[pratimapatel2008]

@ValeKnappich The “available tools” you see in the observation view isn’t currently exposed as a dedicated field on the public trace/observation API objects. The UI derives that section by parsing the observation’s input and metadata, and (since v3.143.0) Langfuse also stores extracted tool definitions internally, but those internal fields haven’t been released on the public API yet. This is tracked in #9525, feel free to upvote/subscribe.

Since the UI builds the tools list purely from input/metadata, everything you see there is already in the API response, you just need to read it from where your integration wrote it:

import json
from langfuse import Langfuse

langfuse = Langfuse()
resp = langfuse.api.observations.get_many(
    trace_id="<trace-id>",
    type="GENERATION",
    fields="core,io,metadata",  # io/metadata aren't in the default projection
)
for obs in resp.data:
    inp = json.loads(obs.input) if isinstance(obs.input, str) else obs.input
    tools = inp.get("tools") if isinstance(inp, dict) else None  # OpenAI-style
    if not tools and obs.metadata:
        attrs = (obs.metadata or {}).get("attributes") or {}
        tools = (attrs.get("gen_ai.tool.definitions")
                 or attrs.get("ai.prompt.tools")
                 or attrs.get("tools"))
    print(obs.id, tools)

Depending on the integration, the definitions live in input.tools (OpenAI SDK wrapper), or in metadata.attributes under keys like ai.prompt.tools (Vercel AI SDK), gen_ai.tool.definitions, llm.tools.{N}.tool.json_schema, or model_request_parameters.function_tools (pydantic-ai).