# WRONG - causes looping and degraded performance
temperature=0.7

# CORRECT - always use default
temperature=1.0  # or omit entirely

You are a friendly, conversational assistant. Explain things in detail with a warm tone.

from google import genai
from google.genai import types

client = genai.Client()

# Low latency for chat
response = client.models.generate_content(
    model="gemini-3-flash-preview",
    contents="Hello, how are you?",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.MINIMAL
        )
    )
)

# High reasoning for complex tasks
response = client.models.generate_content(
    model="gemini-3-flash-preview",
    contents="Solve this optimization problem...",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.HIGH
        )
    )
)

{
  "model": "gemini-3-flash-preview",
  "contents": [{"role": "user", "parts": [{"text": "Your prompt"}]}],
  "generationConfig": {
    "thinkingConfig": {
      "thinkingLevel": "LOW"
    }
  }
}

System: Think silently. Provide direct answers without showing reasoning.

Role + Goal + Constraints + Examples + Output Format

# WRONG - verbose, persuasive
I would really appreciate it if you could please help me summarize
this document. It would be amazing if you could make it concise
and capture all the key points.

# CORRECT - direct
Summarize this document in 3 bullet points. Focus on key findings.

<!-- XML Style -->
<role>You are a technical writer.</role>
<task>Summarize the following code.</task>
<constraints>
- Maximum 100 words
- Use bullet points
</constraints>
<input>
{code_here}
</input>

<!-- Markdown Style -->
## Role
You are a technical writer.

## Task
Summarize the following code.

## Constraints
- Maximum 100 words
- Use bullet points

## Input
{code_here}

<document>
{large_document_content}
</document>

Based on the document above, what are the three main conclusions?

Based on the information provided above...
Using only the data in this document...
According to the context given...

# WRONG - negative constraint at start
Do not use bullet points.
Do not include examples.
Summarize this document about machine learning in 200 words.

# CORRECT - negative constraints at end
Summarize this document about machine learning.
Output must be exactly 200 words.
Do not use bullet points.
Do not include examples.

# WRONG - causes over-indexing, model may refuse basic tasks
Do not infer anything.
Do not guess.
Do not make assumptions.

# CORRECT - specific instruction
Use only the information provided in the document.
If the answer is not explicitly stated, respond with "Not found in document."

# When you receive a function call response:
response = model.generate(...)

# Extract thought signature
thought_signature = response.candidates[0].content.parts[0].thought_signature

# On next turn, include it back:
next_request = {
    "contents": [
        # Previous turns with signatures preserved
        {
            "role": "model",
            "parts": [{
                "functionCall": {...},
                "thoughtSignature": thought_signature  # Return exactly
            }]
        },
        # Function result
        {
            "role": "user",
            "parts": [{"functionResponse": {...}}]
        }
    ]
}

# WRONG - showing what NOT to do
Input: The weather is nice today.
Output: DON'T say "The weather is pleasant" - that's wrong!

# CORRECT - showing what TO do
Input: The weather is nice today.
Output: Current conditions are favorable.

Input: I'm feeling happy.
Output: Emotional state is positive.

Text: The cat sat on the mat.
Sentiment: Neutral

Text: I love this product!
Sentiment: Positive

Text: This is terrible service.
Sentiment: Negative

Text: {user_input}
Sentiment:

from google import genai
from google.genai import types

response = client.models.generate_content(
    model="gemini-3-flash-preview",
    contents="Extract the person's name and age from: John is 25 years old.",
    config=types.GenerateContentConfig(
        response_mime_type="application/json"
    )
)

from google import genai
from google.genai import types

schema = {
    "type": "object",
    "properties": {
        "name": {
            "type": "string",
            "description": "The person's full name"
        },
        "age": {
            "type": "integer",
            "description": "The person's age in years"
        },
        "sentiment": {
            "type": "string",
            "enum": ["positive", "negative", "neutral"],
            "description": "Overall sentiment of the text"
        }
    },
    "required": ["name", "age"]
}

response = client.models.generate_content(
    model="gemini-3-flash-preview",
    contents="Extract info from: John, age 25, loves this product!",
    config=types.GenerateContentConfig(
        response_mime_type="application/json",
        response_schema=schema
    )
)

# GOOD - cacheable prefix
<system_context>
{large_static_content_here}
</system_context>

<user_query>
{variable_user_question}
</user_query>

from google import genai
from google.genai import types

# Create a cache
cache = client.caches.create(
    model="gemini-3-flash-preview",
    contents=[
        types.Content(
            role="user",
            parts=[types.Part(text=large_document)]
        )
    ],
    ttl="3600s"  # 1 hour
)

# Use the cache
response = client.models.generate_content(
    model="gemini-3-flash-preview",
    contents="Summarize the key points.",
    config=types.GenerateContentConfig(
        cached_content=cache.name
    )
)

from google import genai

# Long-running background task
interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    contents="Analyze this codebase and suggest improvements...",
    background=True  # Returns immediately with interaction ID
)

# Check status later
result = client.interactions.get(interaction.name)

## Reasoning Strategy
- Break complex tasks into steps
- Verify information before acting
- Assess risk before state-changing operations

## Execution Rules
- Prefer read operations over writes when uncertain
- Request clarification for ambiguous instructions
- Report blockers immediately

## Output Format
- Explain reasoning before actions
- Confirm completion of each step

from google import genai
from google.genai.types import Tool, GoogleSearch, UrlContext, CodeExecution

tools = [
    Tool(google_search=GoogleSearch()),
    Tool(url_context=UrlContext()),
    Tool(code_execution=CodeExecution())
]

response = client.models.generate_content(
    model="gemini-3-flash-preview",
    contents="Search for latest Python 3.13 features and write example code.",
    config=types.GenerateContentConfig(tools=tools)
)