Gedankensignaturen

Thought Signatures sind verschlüsselte Darstellungen des internen Denkprozesses des Modells. Thought Signatures bewahren den Gemini-Schlussfolgerungsstatus bei Unterhaltungen mit mehreren Runden und mehreren Schritten, was bei der Verwendung von Funktionsaufrufennützlich sein kann. Antworten können in jedem Inhaltsteil (z.B. text, functionCall) ein Feld thought_signature enthalten.

Bei Gemini 3-Modellen wird eine strengere Validierung von Thought Signatures als bei früheren Gemini-Versionen erzwungen, da sie die Modellleistung für Funktionsaufrufe verbessern. Damit das Modell den vollständigen Kontext über mehrere Runden einer Unterhaltung hinweg beibehält, müssen Sie die Thought Signatures aus früheren Antworten in Ihren nachfolgenden Anfragen zurückgeben, auch wenn Sie MINIMAL-Denklevel verwenden. Wenn eine erforderliche Thought Signature bei der Verwendung von Gemini 3-Modellen nicht zurückgegeben wird, gibt das Modell einen 400-Fehler zurück.

Bei Gemini 3 Pro Image wird diese Validierung zwar nicht erzwungen, aber damit das Modell den vollständigen Kontext über mehrere Runden einer Unterhaltung hinweg beibehält, müssen Sie die Thought Signatures aus früheren Antworten in Ihren nachfolgenden Anfragen zurückgeben. Gemini 3 Pro Image gibt keinen 400-Fehler zurück, wenn keine Thought Signature zurückgegeben wird. Codebeispiele zur Bildbearbeitung in mehreren Runden mit Gemini 3 Pro Image finden Sie unter Beispiel für die Bildbearbeitung in mehreren Runden mit Thought Signatures.

Wenn Sie das offizielle Google Gen AI SDK (Python, Node.js, Go oder Java) verwenden und die Standardfunktionen für den Chatverlauf nutzen oder die vollständige Modellantwort an den Verlauf anhängen, werden Thought Signatures automatisch verarbeitet.

Warum sind sie wichtig?

Wenn ein Thinking Model ein externes Tool aufruft, wird der interne Schlussfolgerungsprozess unterbrochen. Die Thought Signature fungiert als „Speicherstatus“, sodass das Modell seine Gedankenkette nahtlos fortsetzen kann, sobald Sie das Ergebnis der Funktion bereitstellen. Ohne Thought Signatures „vergisst“ das Modell seine spezifischen Schlussfolgerungsschritte während der Toolausführungsphase. Wenn Sie die Signatur zurückgeben, wird Folgendes sichergestellt:

  • Kontextkontinuität:Das Modell behält die Schlussfolgerungsschritte bei, die den Aufruf des Tools gerechtfertigt haben, und kann sie überprüfen.
  • Komplexe Schlussfolgerungen:Ermöglicht Aufgaben mit mehreren Schritten, bei denen die Ausgabe eines Tools die Schlussfolgerung für das nächste Tool beeinflusst.

Fortführung der Logikschritte

Bei Gemini 3.5 Flash und neueren Modellen werden die Gedanken aus früheren Runden standardmäßig beibehalten. Der Dienst behält den Gedankenverlauf im Unterhaltungskontext bei, bevor er ihn an das Modell weitergibt.

Wenn Sie den Unterhaltungsverlauf senden, müssen Sie mit früheren Runden übereinstimmen: Entweder Sie fügen den vollständigen Kontext (Gedanken, Funktionsaufrufe und Antworten) ein oder Sie lassen ihn ganz weg. Wenn Sie nur einen Teil des Kontexts bereitstellen, kann die Modellleistung beeinträchtigt werden.

Thought Signatures von anderen Modellen

Flash-Lite-Modelle können keine Gedanken lesen, die von anderen Modellen generiert wurden. Wenn eine Anfrage an ein Flash-Lite-Modell Thought Signatures enthält, die von einem anderen Modell generiert wurden, schlägt die Anfrage nicht fehl. Stattdessen entfernt der Dienst diese Gedanken aus dem Kontext des Modells. Das passiert beispielsweise, wenn Sie eine Anfrage an ein Flash-Lite-Modell mit dem Verlauf eines Gemini Flash- oder Pro-Modells senden.

Runden und Schritte

Ein Mehrfachdialog-Unterhaltungsablauf mit einem Large Language Model (LLM), das Funktionsaufrufe (FC) und Funktionsantworten (FR) verwendet, um eine endgültige Antwort zu generieren. Der Prozess ist in zwei Runden unterteilt: Runde 1 besteht aus drei Schritten. Schritt 1: Der Nutzer-Prompt führt zu Modell FC1. Schritt 2: Das Modell erhält FR1, was zu Modell FC2 führt. Schritt 3: Das Modell empfängt FR2, was zur endgültigen Modellausgabe für Turn 1 führt. Runde 2 beginnt mit einem neuen Nutzer-Prompt, wobei der gesamte Kontext von Runde 1 verwendet wird, um die endgültige Modellausgabe für Runde 2 zu generieren.
Unterhaltungsablauf in mehreren Runden mit Funktionsaufrufen und Antworten.

Im Zusammenhang mit Funktionsaufrufen ist es wichtig, den Unterschied zwischen Runden und Schritten zu verstehen:

  • Eine Runde stellt einen vollständigen Unterhaltungsaustausch dar, der mit einem Prompt des Nutzers beginnt und endet, wenn das Modell eine endgültige Antwort auf diesen Prompt gibt, die keinen Funktionsaufruf enthält.
  • Ein Schritt findet innerhalb einer einzelnen Runde statt, wenn das Modell eine Funktion aufruft und eine Funktionsantwort benötigt, um den Schlussfolgerungsprozess fortzusetzen. Wie im Diagramm zu sehen ist, kann eine einzelne Runde mehrere Schritte umfassen, wenn das Modell mehrere Funktionen nacheinander aufrufen muss, um die Anfrage des Nutzers zu erfüllen.

Thought Signatures verwenden

Die einfachste Möglichkeit, Thought Signatures zu verarbeiten, besteht darin, alle Parts aus allen vorherigen Nachrichten im Unterhaltungsverlauf einzufügen, wenn Sie eine neue Anfrage senden, genau so, wie sie vom Modell zurückgegeben wurden.

Wenn Sie kein Google Gen AI SDK verwenden oder den Unterhaltungsverlauf ändern oder kürzen müssen, müssen Sie darauf achten, dass Thought Signatures beibehalten und an das Modell zurückgesendet werden.

Bei Verwendung des Google Gen AI SDK (empfohlen)

Wenn Sie die Funktionen für den Chatverlauf der SDKs verwenden oder das Modell's content Objekt aus der vorherigen Antwort an die contents der nächsten Anfrage anhängen, werden Signaturen automatisch verarbeitet.

Das folgende Python-Beispiel zeigt die automatische Verarbeitung:

from google import genai
from google.genai.types import Content, FunctionDeclaration, GenerateContentConfig, Part, ThinkingConfig, Tool

client = genai.Client()

# 1. Define your tool
get_weather_declaration = FunctionDeclaration(
   name="get_weather",
   description="Gets the current weather temperature for a given location.",
   parameters={
       "type": "object",
       "properties": {"location": {"type": "string"}},
       "required": ["location"],
   },
)
get_weather_tool = Tool(function_declarations=[get_weather_declaration])

# 2. Send a message that triggers the tool
prompt = "What's the weather like in London?"
response = client.models.generate_content(
   model="gemini-3.5-flash",
   contents=prompt,
   config=GenerateContentConfig(
       tools=[get_weather_tool],
       thinking_config=ThinkingConfig(include_thoughts=True)
   ),
)

# 3. Handle the function call
function_call = response.function_calls[0]
location = function_call.args["location"]
print(f"Model wants to call: {function_call.name}")

# Execute your tool (for example, call an API)
# (This is a mock response for the example)
print(f"Calling external tool for: {location}")
function_response_data = {
   "location": location,
   "temperature": "30C",
}

# 4. Send the tool's result back
# Append this turn's messages to history for a final response.
# The `content` object automatically attaches the required thought_signature behind the scenes.
history = [
   Content(role="user", parts=[Part(text=prompt)]),
   response.candidates[0].content, # Signature preserved here
   Content(
     role="tool",
     parts=[
         Part.from_function_response(
             name=function_call.name,
             response=function_response_data,
         )
     ],
   )
]

response_2 = client.models.generate_content(
   model="gemini-3.5-flash",
   contents=history,
   config=GenerateContentConfig(
       tools=[get_weather_tool],
       thinking_config=ThinkingConfig(include_thoughts=True)
   ),
)

# 5. Get the final, natural-language answer
print(f"\nFinal model response: {response_2.text}")

Bei Verwendung von REST oder manueller Verarbeitung

Wenn Sie direkt mit der API interagieren, müssen Sie die Signaturverarbeitung gemäß den folgenden Regeln für Gemini 3 Pro implementieren:

  • Funktionsaufrufe:
    • Wenn die Modellantwort einen oder mehrere functionCall-Teile enthält, ist eine thought_signature für die korrekte Verarbeitung erforderlich.
    • Bei parallelen Funktionsaufrufen in einer einzelnen Antwort enthält nur der erste functionCall-Teil die thought_signature.
    • Bei sequenziellen Funktionsaufrufen über mehrere Schritte in einer Runde enthält jeder functionCall-Teil eine thought_signature.
    • Regel: Wenn Sie die nächste Anfrage erstellen, müssen Sie den part mit dem functionCall und seiner thought_signature genau so einfügen, wie er vom Modell zurückgegeben wurde. Bei sequenziellen (mehrstufigen) Funktionsaufrufen wird die Validierung für alle Schritte in der aktuellen Runde durchgeführt. Wenn Sie eine erforderliche thought_signature für den ersten functionCall-Teil in einem Schritt der aktuellen Runde weglassen, führt das zu einem 400-Fehler. Eine Runde beginnt mit der letzten Nutzernachricht, die keine functionResponse ist.
    • Wenn das Modell parallele Funktionsaufrufe zurückgibt (z. B. FC1+signature, FC2), muss Ihre Antwort alle Funktionsaufrufe gefolgt von allen Funktionsantworten enthalten (FC1+signature, FC2, FR1, FR2). Wenn Sie Antworten verschachteln (FC1+signature, FR1, FC2, FR2), führt das zu einem 400-Fehler.
    • In seltenen Fällen müssen Sie functionCall-Teile bereitstellen, die nicht von der API generiert wurden und daher keine zugehörige Thought Signature haben (z. B. beim Übertragen des Verlaufs von einem Modell, das keine Thought Signatures enthält). Sie können thought_signature auf skip_thought_signature_validator setzen. Das sollte jedoch nur als letzter Ausweg dienen, da es die Modellleistung negativ beeinflusst.
  • Keine Funktionsaufrufe:
    • Wenn die Modellantwort keinen functionCall enthält, kann sie eine thought_signature im letzten part der Antwort enthalten (z. B. im letzten text-Teil).
    • Regel: Es wird empfohlen, diese Signatur in die nächste Anfrage einzufügen, um die beste Leistung zu erzielen. Wenn Sie sie weglassen, führt das jedoch nicht zu einem Fehler. Beim Streaming wird diese Signatur möglicherweise in einem Teil mit leerem Textinhalt zurückgegeben. Achten Sie daher darauf, alle Teile zu parsen, bis finish_reason vom Modell zurückgegeben wird.

Beachten Sie diese Regeln, um sicherzustellen, dass der Kontext des Modells beibehalten wird:

  • Senden Sie die thought_signature immer in ihrem ursprünglichen Part an das Modell zurück.
  • Führen Sie keinen Part mit einer Signatur mit einem ohne Signatur zusammen. Dadurch wird der Positionierungskontext des Gedankens unterbrochen.
  • Kombinieren Sie keine zwei Parts, die beide Signaturen enthalten, da die Signaturstrings nicht zusammengeführt werden können.

Beispiel für sequenzielle Funktionsaufrufe

Das folgende Beispiel zeigt einen mehrstufigen Funktionsaufruf, bei dem der Nutzer fragt: „Check flight status for AA100 and book a taxi if delayed“ (Flugstatus für AA100 prüfen und bei Verspätung ein Taxi buchen). Dafür sind mehrere Aufgaben erforderlich.

REST

Das folgende Beispiel zeigt, wie Sie Thought Signatures über mehrere Schritte in einem sequenziellen Funktionsaufruf-Workflow mit der REST API verarbeiten.

Runde 1, Schritt 1 (Nutzeranfrage)
{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "check_flight",
          "description": "Gets the current status of a flight",
          "parameters": {
            "type": "object",
            "properties": {
              "flight": {
                "type": "string",
                "description": "The flight number to check"
              }
            },
            "required": [
              "flight"
            ]
          }
        },
        {
          "name": "book_taxi",
          "description": "Book a taxi",
          "parameters": {
            "type": "object",
            "properties": {
              "time": {
                "type": "string",
                "description": "time to book the taxi"
              }
            },
            "required": [
              "time"
            ]
          }
        }
      ]
    }
  ]
}
Runde 1, Schritt 1 (Modellantwort)
{
"content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<SIGNATURE_A>"
          }
        ]
  }
}
Runde 1, Schritt 2 (Nutzerantwort – Toolausgaben senden)

Da diese Nutzerrunde nur eine functionResponse (kein neuer Text) enthält, befinden wir uns noch in Runde 1. Sie müssen <SIGNATURE_A> beibehalten.

{
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    },
    {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<SIGNATURE_A>"
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "check_flight",
              "response": {
                "status": "delayed",
                "departure_time": "12 PM"
                }
              }
            }
        ]
}
Runde 1, Schritt 2 (Modellantwort)

Das Modell beschließt nun, basierend auf der vorherigen Toolausgabe ein Taxi zu buchen.

{
      "content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "book_taxi",
              "args": {
                "time": "10 AM"
              }
            },
            "thoughtSignature": "<SIGNATURE_B>"
          }
        ]
      }
}
Runde 1, Schritt 3 (Nutzerantwort – Toolausgabe senden)

Um die Taxibuchungsbestätigung zu senden, müssen Sie Signaturen für alle Funktionsaufrufe in dieser Schleife einfügen (<SIGNATURE_A> und <SIGNATURE_B>).

{
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    },
    {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<SIGNATURE_A>"
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "check_flight",
              "response": {
                "status": "delayed",
                "departure_time": "12 PM"
              }
              }
            }
        ]
      },
      {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "book_taxi",
              "args": {
                "time": "10 AM"
              }
            },
            "thoughtSignature": "<SIGNATURE_B>"
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "book_taxi",
              "response": {
                "booking_status": "success"
              }
              }
            }
        ]
    }
}

Chat-Vervollständigungen

Das folgende Beispiel zeigt, wie Sie Thought Signatures über mehrere Schritte in einem sequenziellen Funktionsaufruf-Workflow mit der Chat Completions API verarbeiten.

Runde 1, Schritt 1 (Nutzeranfrage)
{
  "model": "google/gemini-3.1-pro-preview",
  "messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "check_flight",
        "description": "Gets the current status of a flight",
        "parameters": {
          "type": "object",
          "properties": {
            "flight": {
              "type": "string",
              "description": "The flight number to check."
            }
          },
          "required": [
            "flight"
          ]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "book_taxi",
        "description": "Book a taxi",
        "parameters": {
          "type": "object",
          "properties": {
            "time": {
              "type": "string",
              "description": "time to book the taxi"
            }
          },
          "required": [
            "time"
          ]
        }
      }
    }
  ]
}
Runde 1, Schritt 1 (Modellantwort)
{
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1",
            "type": "function"
          }
        ]
    }
Runde 1, Schritt 2 (Nutzerantwort – Toolausgaben senden)

Da diese Nutzerrunde nur eine functionResponse (kein neuer Text) enthält, befinden wir uns noch in Runde 1. Sie müssen <SIGNATURE_A> beibehalten.

"messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "check_flight",
      "tool_call_id": "function-call-1",
      "content": "{\"status\":\"delayed\",\"departure_time\":\"12 PM\"}"
    }
  ]
Runde 1, Schritt 2 (Modellantwort)

Das Modell beschließt nun, basierend auf der vorherigen Toolausgabe ein Taxi zu buchen.

{
"role": "model",
"tool_calls": [
{
"extra_content": {
"google": {
"thought_signature": "<SIGNATURE_B>"
}
            },
            "function": {
              "arguments": "{\"time\":\"10 AM\"}",
              "name": "book_taxi"
            },
            "id": "function-call-2",
            "type": "function"
          }
       ]
}
Runde 1, Schritt 3 (Nutzerantwort – Toolausgabe senden)

Um die Taxibuchungsbestätigung zu senden, müssen Sie Signaturen für alle Funktionsaufrufe in dieser Schleife einfügen (<SIGNATURE_A> und <SIGNATURE_B>).

"messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1d6a1a61-6f4f-4029-80ce-61586bd86da5",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "check_flight",
      "tool_call_id": "function-call-1d6a1a61-6f4f-4029-80ce-61586bd86da5",
      "content": "{\"status\":\"delayed\",\"departure_time\":\"12 PM\"}"
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_B>"
              }
            },
            "function": {
              "arguments": "{\"time\":\"10 AM\"}",
              "name": "book_taxi"
            },
            "id": "function-call-65b325ba-9b40-4003-9535-8c7137b35634",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "book_taxi",
      "tool_call_id": "function-call-65b325ba-9b40-4003-9535-8c7137b35634",
      "content": "{\"booking_status\":\"success\"}"
    }
  ]

Beispiel für parallele Funktionsaufrufe

Das folgende Beispiel zeigt einen parallelen Funktionsaufruf, bei dem der Nutzer fragt: „Check weather in Paris and London“ (Wetter in Paris und London prüfen).

REST

Das folgende Beispiel zeigt, wie Sie Thought Signatures in einem parallelen Funktionsaufruf-Workflow mit der REST API verarbeiten.

Runde 1, Schritt 1 (Nutzeranfrage)
{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check the weather in Paris and London."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "get_current_temperature",
          "description": "Gets the current temperature for a given location.",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city name, e.g. San Francisco"
              }
            },
            "required": [
              "location"
            ]
          }
        }
      ]
    }
  ]
}
Runde 1, Schritt 1 (Modellantwort)
{
  "content": {
    "parts": [
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "location": "Paris"
          }
        },
        "thoughtSignature": "<SIGNATURE_A>"
      },
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "location": "London"
          }
        }
      }
    ]
  }
}
Runde 1, Schritt 2 (Nutzerantwort – Toolausgaben senden)

Sie müssen <SIGNATURE_A> im ersten Teil genau so beibehalten, wie Sie sie erhalten haben.

[
  {
    "role": "user",
    "parts": [
      {
        "text": "Check the weather in Paris and London."
      }
    ]
  },
  {
    "role": "model",
    "parts": [
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "city": "Paris"
          }
        },
        "thought_signature": "<SIGNATURE_A>"
      },
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "city": "London"
          }
        }
      }
    ]
  },
  {
    "role": "user",
    "parts": [
      {
        "functionResponse": {
          "name": "get_current_temperature",
          "response": {
            "temp": "15C"
          }
        }
      },
      {
        "functionResponse": {
        "functionResponse": {
          "name": "get_current_temperature",
          "response": {
            "temp": "12C"
          }
        }
      }
    ]
  }
]

Chat-Vervollständigungen

Das folgende Beispiel zeigt, wie Sie Thought Signatures in einem parallelen Funktionsaufruf-Workflow mit der Chat Completions API verarbeiten.

Runde 1, Schritt 1 (Nutzeranfrage)
{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check the weather in Paris and London."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "get_current_temperature",
          "description": "Gets the current temperature for a given location.",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city name, e.g. San Francisco"
              }
            },
            "required": [
              "location"
            ]
          }
        }
      ]
    }
  ]
}
Runde 1, Schritt 1 (Modellantwort)
{
"role": "assistant",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"location\":\"Paris\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
            "type": "function"
          },
          {
            "function": {
              "arguments": "{\"location\":\"London\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
            "type": "function"
          }
        ]
}
Runde 1, Schritt 2 (Nutzerantwort – Toolausgaben senden)

Sie müssen <SIGNATURE_A> im ersten Teil genau so beibehalten, wie Sie sie erhalten haben.

"messages": [
    {
      "role": "user",
      "content": "Check the weather in Paris and London."
    },
    {
      "role": "assistant",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"location\":\"Paris\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
            "type": "function"
          },
          {
            "function": {
              "arguments": "{\"location\":\"London\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
            "type": "function"
          }
        ]
    },
    {
      "role":"tool",
      "name": "get_current_temperature",
      "tool_call_id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
      "content": "{\"temp\":\"15C\"}"
    },
    {
      "role":"tool",
      "name": "get_current_temperature",
      "tool_call_id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
      "content": "{\"temp\":\"12C\"}"
    }
  ]

Signaturen in Parts, die keine functionCall sind

Gemini kann auch eine thought_signature im letzten Part einer Antwort zurückgeben, auch wenn kein Funktionsaufruf vorhanden ist.

  • Verhalten:Der letzte Part (text, inlineData usw.), der vom Modell zurückgegeben wird, kann eine thought_signature enthalten.
  • Anforderung:Es wird empfohlen , diese Signatur zurückzugeben, damit das Modell hochwertige Schlussfolgerungen ziehen kann, insbesondere bei komplexen Anweisungen oder simulierten Agenten-Workflows.
  • Validierung:Die API erzwingt die Validierung für Signaturen in `Part`s, die keine functionCall sind, nicht. Wenn Sie sie weglassen, erhalten Sie keinen blockierenden Fehler, aber die Leistung kann beeinträchtigt werden.

Beispiel für eine Modellantwort mit Signatur im Textteil:

Die folgenden Beispiele zeigen eine Modellantwort, in der eine thought_signature in einem Part enthalten ist, der keine functionCall ist, und wie Sie sie in einer nachfolgenden Anfrage verarbeiten.

Runde 1, Schritt 1 (Modellantwort)
{
  "role": "model",
  "parts": [
    {
      "text": "I need to calculate the risk. Let me think step-by-step...",
      "thought_signature": "<SIGNATURE_C>" // OPTIONAL (Recommended)
    }
  ]
}
Runde 2, Schritt 1 (Nutzer)
[
  { "role": "user", "parts": [{ "text": "What is the risk?" }] },
  {
    "role": "model",
    "parts": [
      {
        "text": "I need to calculate the risk. Let me think step-by-step...",
        // If you omit <SIGNATURE_C> here, no error will occur.
      }
    ]
  },
  { "role": "user", "parts": [{ "text": "Summarize it." }] }
]

Beispiel für die Bildbearbeitung in mehreren Runden mit Thought Signatures

Die folgenden Beispiele zeigen, wie Sie Thought Signatures während der Bildbearbeitung in mehreren Runden mit Gemini 3 Pro Image abrufen und weitergeben.

Runde 1: Antwort abrufen und Daten speichern, die Thought Signatures enthalten

chat = client.chats.create(
   model="gemini-3-pro-image-preview",
   config=types.GenerateContentConfig(
       response_modalities=['TEXT', 'IMAGE']
   )
)
message = "Create an image of a clear perfume bottle sitting on a vanity."
response = chat.send_message(message)
data = b''
for part in response.candidates[0].content.parts:
   if part.text:
       display(Markdown(part.text))
   if part.inline_data:
       data = part.inline_data.data
       display(Image(data=data, width=500))

Runde 2: Daten weitergeben, die Thought Signatures enthalten

response = chat.send_message(
   message=[
       types.Part.from_bytes(
           data=data,
           mime_type="image/png",
       ),
       "Make the perfume bottle purple and add a vase of hydrangeas next to the bottle.",
   ],
)
for part in response.candidates[0].content.parts:
   if part.text:
       display(Markdown(part.text))
   if part.inline_data:
       display(Image(data=part.inline_data.data, width=500))

Nächste Schritte

Übersicht

Informationen zu den Denkfähigkeiten von Gemini und zum Konfigurieren von Denkleveln

Anleitung

Informationen zu Prompt-Engineering-Techniken und Best Practices, die auf Gemini Thinking Models zugeschnitten sind

Anleitung

Informationen dazu, wie Sie Gemini-Modelle mithilfe von Funktionsaufrufen externe Tools während der Antwortgenerierung verwenden lassen