How to get the raw LLM request?

[mark-church]

Challenge/request
I am trying to see the raw LLM request that is sent to the LLM for any given agent call. I want to see the exact text that is sent to the LLM because that makes it easier to experiment. I can use direct LLM calls to experiment with the structure of the prompt locally to see what works best before seeing how to format and structure things for ADK.

Attempted so far
I have used verbose logging and different callbacks to print out various pieces of context with llm_request.contents, llm_request.config.system_instruction, and others, but it's not clear which of these pieces are actually sent in the LLM request, in what structure, and in what order.

Is there a way of seeing exactly what is sent to the LLM? Or maybe specify which fields of the llm_request are sent and how they are structured in the prompt? It might also be nice to make it easy to see this with a specific field in llm_request that just has the full unstructured text of what is sent in the request.

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: You can see the raw LLM request by using verbose logging, implementing a before_model_callback, or creating a custom logging plugin.

---

Hello! As an AI assistant for the ADK, I can provide some information on how to view the raw request sent to the LLM. Here are a few methods you can use:

Verbose Logging

The most straightforward way to see the full LLM prompt is by enabling verbose logging. When the log level is set to DEBUG, the ADK will automatically log the entire prompt, which includes system instructions, conversation history, and any tools provided to the LLM. [1]

You can enable this in your Python script:

import logging
logging.basicConfig(level=logging.DEBUG)

Or by using the --log_level DEBUG or -v flag when running the ADK command-line interface (CLI). [1]

Using Callbacks

For more granular control, you can use the before_model_callback. This callback is triggered just before the request is sent to the LLM, giving you access to the LlmRequest object. This object contains the complete payload that will be sent to the model. [2, 3]

The llm_request object has two important attributes:

• contents: This holds the conversation history and the latest user message. [2]
• config: This contains other request parameters, such as temperature, top_p, and stop sequences. [2]

Here is an example of how you can implement a before_model_callback to print the request:

from google.adk.model import LlmRequest
from google.adk.runtime.sync import CallbackContext

def log_llm_request(callback_context: CallbackContext, llm_request: LlmRequest):
  """A callback to print the LLM request."""
  print("LLM Request:")
  print(llm_request)

# You can then add this callback to your agent or runner.

You can find a more detailed example in the documentation. [4]

Custom Logging Plugins

If you want to apply this logging behavior across multiple agents or runs, you can create a custom plugin. Plugins allow you to package callbacks and apply them globally. [5, 6]

You can create a new plugin by inheriting from the BasePlugin class and implementing the before_model_callback method. [7, 8] The LoggingPlugin that comes with the ADK is a great example to follow. [9]

By creating a custom plugin, you can easily enable or disable this logging behavior as needed without modifying your agent code. [10]

I hope this information helps you experiment with and debug your prompts!

---

References:

[1] https://google.github.io/adk-docs/observability/logging/
[2] https://google.github.io/adk-docs/callbacks/
[3] https://github.com/google/adk-docs/blob/main/examples/python/snippets/callbacks/before_model_callback.py
[4] https://github.com/google/adk-docs/blob/main/examples/python/snippets/callbacks/before_model_callback.py
[5] https://google.github.io/adk-docs/plugins/
[6] https://google.github.io/adk-docs/tutorials/agent-team/
[7] https://github.com/google/adk-python/blob/main/src/google/adk/plugins/base_plugin.py
[8] https://github.com/google/adk-python/blob/main/contributing/samples/plugin_basic/README.md
[9] https://github.com/google/adk-python/blob/main/src/google/adk/plugins/logging_plugin.py
[10] https://google.github.io/adk-docs/tutorials/agent-team/

[boyangsvl]

The logging plugin is here: https://github.com/google/adk-python/blob/main/src/google/adk/plugins/logging_plugin.py

[mark-church]

Thanks, so this is what I was wondering ... below is the output from my llm_request. Is this the text that is sent verbatim as the LLM request? Or is it formatted in some other way via markdown or XML tags? I'm just wondering because this seems like fairly non-standard way of prompting and I'm trying to do localized prompt experimentation in the console so I want to make sure that I am writing out the LLM request exactly as the LLM would see it in ADK.

model='gemini-2.5-pro' contents=[Content(
  parts=[
    Part(
      text="""... user input text ...
"""
    ),
  ],
  role='user'
)] config=GenerateContentConfig(
  system_instruction="""
       ... system instructions ...

You are an agent. Your internal name is "test_agent".

 The description about you is "A test agent"""",
  thinking_config=ThinkingConfig(
    include_thoughts=True,
    thinking_budget=1024
  ),
  tools=[
    Tool(
      function_declarations=[
        FunctionDeclaration(
          description="""
              ... tool1 description ...
    """,
          name='tool1',
          parameters=Schema(
            properties={
              <... Max depth ...>: <... Max depth ...>,
              <... Max depth ...>: <... Max depth ...>
            },
            required=[
              <... Max depth ...>,
            ],
            type=<Type.OBJECT: 'OBJECT'>
          ),
          response=Schema(
            type=<Type.STRING: 'STRING'>
          )
        ),
        FunctionDeclaration(
          description="""... tool2 description ...""",
          name='tool2',
          parameters=Schema(
            properties={
              <... Max depth ...>: <... Max depth ...>,
              <... Max depth ...>: <... Max depth ...>,
              <... Max depth ...>: <... Max depth ...>,
              <... Max depth ...>: <... Max depth ...>
            },
            required=[
              <... Max depth ...>,
              <... Max depth ...>,
            ],
            type=<Type.OBJECT: 'OBJECT'>
          )
        ),
...
        ),
      ]
    ),
  ]
) live_connect_config=LiveConnectConfig() tools_dict=
{'tool1': <google.adk.tools.function_tool.FunctionTool object at 0x149c4c770>, 
'tool2': <google.adk.tools.function_tool.FunctionTool object at 0x163a64cb0>, ...}

[boyangsvl]

No this is the internal ADK class that represents the request. The actual request sent to the model is different, e.g. if you use GPT models, this will be converted to the GPT schema. If you want the raw bytes that is sent to the model, try change the files under adk/models folder to add some logging.

[alaliaa]

No this is the internal ADK class that represents the request. The actual request sent to the model is different, e.g. if you use GPT models, this will be converted to the GPT schema. If you want the raw bytes that is sent to the model, try change the files under adk/models folder to add some logging.

I have been wondering about the same thing. I am trying to check the actual request send to the LLM model.

For not Gemini models, I found that using litellm._turn_on_debug() to be very effective and it gives you the actual request. For Gemini models, however, I am not sure how to do this.

Just so the goal is clear, I aim to get the actual raw request and inspect all the tools output format in order to optimize my context window.