21

app.py

@@ -39,7 +39,7 @@ DEFAULT_TOOLS = [
 conversations = {}
 conversation_metadata = {}
 
-def add_message_to_history(conversation_id, role, content, has_file=False):
+def add_message_to_history(conversation_id, role, content, has_file=False, file_data=None):
     """Ajoute un message à l'historique de la conversation"""
     if conversation_id not in conversation_metadata:
         conversation_metadata[conversation_id] = {
@@ -50,12 +50,15 @@ def add_message_to_history(conversation_id, role, content, has_file=False):
             'status': 'active'
         }
     
-    conversation_metadata[conversation_id]['messages'].append({
+    message_data = {
         'role': role,
         'content': content,
         'timestamp': datetime.now().isoformat(),
         'hasFile': has_file
-    })
+    }
+    if file_data:
+        message_data['fileData'] = file_data
+    conversation_metadata[conversation_id]['messages'].append(message_data)
     conversation_metadata[conversation_id]['last_activity'] = datetime.now().isoformat()
 
 @app.route('/')
@@ -213,7 +216,7 @@ def chat_with_file():
         display_message = message if message else 'Analyse ce fichier'
         if file_data:
             display_message += f" [Fichier: {file_data.get('filename', 'inconnu')}]"
-        add_message_to_history(conversation_id, 'user', display_message, has_file=True)
+        add_message_to_history(conversation_id, 'user', display_message, has_file=True, file_data=file_data)
         
         # Configuration du thinking
         config_dict = DEFAULT_CONFIG.copy()

documentation_gemini/audio_understanding.md

@@ -0,0 +1,158 @@
+# Audio understanding
+
+Source: <https://ai.google.dev/gemini-api/docs/audio>
+
+---
+
+Gemini can analyze and understand audio input, enabling use cases like the following:
+
+  * Describe, summarize, or answer questions about audio content.
+  * Provide a transcription of the audio.
+  * Analyze specific segments of the audio.
+
+
+
+This guide shows you how to use the Gemini API to generate a text response to audio input.
+
+### Before you begin
+
+Before calling the Gemini API, ensure you have [your SDK of choice](/gemini-api/docs/downloads) installed, and a [Gemini API key](/gemini-api/docs/api-key) configured and ready to use.
+
+## Input audio
+
+You can provide audio data to Gemini in the following ways:
+
+  * Upload an audio file before making a request to `generateContent`.
+  * Pass inline audio data with the request to `generateContent`.
+
+
+
+### Upload an audio file
+
+You can use the [Files API](/gemini-api/docs/files) to upload an audio file. Always use the Files API when the total request size (including the files, text prompt, system instructions, etc.) is larger than 20 MB.
+
+The following code uploads an audio file and then uses the file in a call to `generateContent`.
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    
+    myfile = client.files.upload(file="path/to/sample.mp3")
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash", contents=["Describe this audio clip", myfile]
+    )
+    
+    print(response.text)
+    
+
+To learn more about working with media files, see [Files API](/gemini-api/docs/files).
+
+### Pass audio data inline
+
+Instead of uploading an audio file, you can pass inline audio data in the request to `generateContent`:
+    
+    
+    from google.genai import types
+    
+    with open('path/to/small-sample.mp3', 'rb') as f:
+        audio_bytes = f.read()
+    
+    response = client.models.generate_content(
+      model='gemini-2.5-flash',
+      contents=[
+        'Describe this audio clip',
+        types.Part.from_bytes(
+          data=audio_bytes,
+          mime_type='audio/mp3',
+        )
+      ]
+    )
+    
+    print(response.text)
+    
+
+A few things to keep in mind about inline audio data:
+
+  * The maximum request size is 20 MB, which includes text prompts, system instructions, and files provided inline. If your file's size will make the _total request size_ exceed 20 MB, then use the Files API to upload an audio file for use in the request.
+  * If you're using an audio sample multiple times, it's more efficient to upload an audio file.
+
+
+
+## Get a transcript
+
+To get a transcript of audio data, just ask for it in the prompt:
+    
+    
+    myfile = client.files.upload(file='path/to/sample.mp3')
+    prompt = 'Generate a transcript of the speech.'
+    
+    response = client.models.generate_content(
+      model='gemini-2.5-flash',
+      contents=[prompt, myfile]
+    )
+    
+    print(response.text)
+    
+
+## Refer to timestamps
+
+You can refer to specific sections of an audio file using timestamps of the form `MM:SS`. For example, the following prompt requests a transcript that
+
+  * Starts at 2 minutes 30 seconds from the beginning of the file.
+  * Ends at 3 minutes 29 seconds from the beginning of the file.
+
+
+
+    
+    
+    # Create a prompt containing timestamps.
+    prompt = "Provide a transcript of the speech from 02:30 to 03:29."
+    
+
+## Count tokens
+
+Call the `countTokens` method to get a count of the number of tokens in an audio file. For example:
+    
+    
+    response = client.models.count_tokens(
+      model='gemini-2.5-flash',
+      contents=[myfile]
+    )
+    
+    print(response)
+    
+
+## Supported audio formats
+
+Gemini supports the following audio format MIME types:
+
+  * WAV - `audio/wav`
+  * MP3 - `audio/mp3`
+  * AIFF - `audio/aiff`
+  * AAC - `audio/aac`
+  * OGG Vorbis - `audio/ogg`
+  * FLAC - `audio/flac`
+
+
+
+## Technical details about audio
+
+  * Gemini represents each second of audio as 32 tokens; for example, one minute of audio is represented as 1,920 tokens.
+  * Gemini can "understand" non-speech components, such as birdsong or sirens.
+  * The maximum supported length of audio data in a single prompt is 9.5 hours. Gemini doesn't limit the _number_ of audio files in a single prompt; however, the total combined length of all audio files in a single prompt can't exceed 9.5 hours.
+  * Gemini downsamples audio files to a 16 Kbps data resolution.
+  * If the audio source contains multiple channels, Gemini combines those channels into a single channel.
+
+
+
+## What's next
+
+This guide shows how to generate text in response to audio data. To learn more, see the following resources:
+
+  * [File prompting strategies](/gemini-api/docs/files#prompt-guide): The Gemini API supports prompting with text, image, audio, and video data, also known as multimodal prompting.
+  * [System instructions](/gemini-api/docs/text-generation#system-instructions): System instructions let you steer the behavior of the model based on your specific needs and use cases.
+  * [Safety guidance](/gemini-api/docs/safety-guidance): Sometimes generative AI models produce unexpected outputs, such as outputs that are inaccurate, biased, or offensive. Post-processing and human evaluation are essential to limit the risk of harm from such outputs.
+
+

documentation_gemini/code_execution.md

@@ -0,0 +1,258 @@
+# Code execution
+
+Source: <https://ai.google.dev/gemini-api/docs/code-execution>
+
+---
+
+The Gemini API provides a code execution tool that enables the model to generate and run Python code. The model can then learn iteratively from the code execution results until it arrives at a final output. You can use code execution to build applications that benefit from code-based reasoning. For example, you can use code execution to solve equations or process text. You can also use the libraries included in the code execution environment to perform more specialized tasks.
+
+Gemini is only able to execute code in Python. You can still ask Gemini to generate code in another language, but the model can't use the code execution tool to run it.
+
+## Enable code execution
+
+To enable code execution, configure the code execution tool on the model. This allows the model to generate and run code.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="What is the sum of the first 50 prime numbers? "
+        "Generate and run code for the calculation, and make sure you get all 50.",
+        config=types.GenerateContentConfig(
+            tools=[types.Tool(code_execution=types.ToolCodeExecution)]
+        ),
+    )
+    
+    for part in response.candidates[0].content.parts:
+        if part.text is not None:
+            print(part.text)
+        if part.executable_code is not None:
+            print(part.executable_code.code)
+        if part.code_execution_result is not None:
+            print(part.code_execution_result.output)
+    
+
+The output might look something like the following, which has been formatted for readability:
+    
+    
+    Okay, I need to calculate the sum of the first 50 prime numbers. Here's how I'll
+    approach this:
+    
+    1.  **Generate Prime Numbers:** I'll use an iterative method to find prime
+        numbers. I'll start with 2 and check if each subsequent number is divisible
+        by any number between 2 and its square root. If not, it's a prime.
+    2.  **Store Primes:** I'll store the prime numbers in a list until I have 50 of
+        them.
+    3.  **Calculate the Sum:**  Finally, I'll sum the prime numbers in the list.
+    
+    Here's the Python code to do this:
+    
+    def is_prime(n):
+      """Efficiently checks if a number is prime."""
+      if n <= 1:
+        return False
+      if n <= 3:
+        return True
+      if n % 2 == 0 or n % 3 == 0:
+        return False
+      i = 5
+      while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+          return False
+        i += 6
+      return True
+    
+    primes = []
+    num = 2
+    while len(primes) < 50:
+      if is_prime(num):
+        primes.append(num)
+      num += 1
+    
+    sum_of_primes = sum(primes)
+    print(f'{primes=}')
+    print(f'{sum_of_primes=}')
+    
+    primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
+    71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
+    157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229]
+    sum_of_primes=5117
+    
+    The sum of the first 50 prime numbers is 5117.
+    
+
+This output combines several content parts that the model returns when using code execution:
+
+  * `text`: Inline text generated by the model
+  * `executableCode`: Code generated by the model that is meant to be executed
+  * `codeExecutionResult`: Result of the executable code
+
+
+
+The naming conventions for these parts vary by programming language.
+
+## Use code execution in chat
+
+You can also use code execution as part of a chat.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    chat = client.chats.create(
+        model="gemini-2.5-flash",
+        config=types.GenerateContentConfig(
+            tools=[types.Tool(code_execution=types.ToolCodeExecution)]
+        ),
+    )
+    
+    response = chat.send_message("I have a math question for you.")
+    print(response.text)
+    
+    response = chat.send_message(
+        "What is the sum of the first 50 prime numbers? "
+        "Generate and run code for the calculation, and make sure you get all 50."
+    )
+    
+    for part in response.candidates[0].content.parts:
+        if part.text is not None:
+            print(part.text)
+        if part.executable_code is not None:
+            print(part.executable_code.code)
+        if part.code_execution_result is not None:
+            print(part.code_execution_result.output)
+    
+
+## Input/output (I/O)
+
+Starting with [Gemini 2.0 Flash](/gemini-api/docs/models/gemini#gemini-2.0-flash), code execution supports file input and graph output. Using these input and output capabilities, you can upload CSV and text files, ask questions about the files, and have [Matplotlib](https://matplotlib.org/) graphs generated as part of the response. The output files are returned as inline images in the response.
+
+### I/O pricing
+
+When using code execution I/O, you're charged for input tokens and output tokens:
+
+**Input tokens:**
+
+  * User prompt
+
+
+
+**Output tokens:**
+
+  * Code generated by the model
+  * Code execution output in the code environment
+  * Thinking tokens
+  * Summary generated by the model
+
+
+
+### I/O details
+
+When you're working with code execution I/O, be aware of the following technical details:
+
+  * The maximum runtime of the code environment is 30 seconds.
+  * If the code environment generates an error, the model may decide to regenerate the code output. This can happen up to 5 times.
+  * The maximum file input size is limited by the model token window. In AI Studio, using Gemini Flash 2.0, the maximum input file size is 1 million tokens (roughly 2MB for text files of the supported input types). If you upload a file that's too large, AI Studio won't let you send it.
+  * Code execution works best with text and CSV files.
+  * The input file can be passed in `part.inlineData` or `part.fileData` (uploaded via the [Files API](/gemini-api/docs/files)), and the output file is always returned as `part.inlineData`.
+
+| Single turn | Bidirectional (Multimodal Live API)  
+---|---|---  
+Models supported | All Gemini 2.0 and 2.5 models | Only Flash experimental models  
+File input types supported | .png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts | .png, .jpeg, .csv, .xml, .cpp, .java, .py, .js, .ts  
+Plotting libraries supported | Matplotlib, seaborn | Matplotlib, seaborn  
+[Multi-tool use](/gemini-api/docs/function-calling#multi-tool-use) | Yes (code execution + grounding only) | Yes  
+  
+## Billing
+
+There's no additional charge for enabling code execution from the Gemini API. You'll be billed at the current rate of input and output tokens based on the Gemini model you're using.
+
+Here are a few other things to know about billing for code execution:
+
+  * You're only billed once for the input tokens you pass to the model, and you're billed for the final output tokens returned to you by the model.
+  * Tokens representing generated code are counted as output tokens. Generated code can include text and multimodal output like images.
+  * Code execution results are also counted as output tokens.
+
+
+
+The billing model is shown in the following diagram:
+
+![code execution billing model](/static/gemini-api/docs/images/code-execution-diagram.png)
+
+  * You're billed at the current rate of input and output tokens based on the Gemini model you're using.
+  * If Gemini uses code execution when generating your response, the original prompt, the generated code, and the result of the executed code are labeled _intermediate tokens_ and are billed as _input tokens_.
+  * Gemini then generates a summary and returns the generated code, the result of the executed code, and the final summary. These are billed as _output tokens_.
+  * The Gemini API includes an intermediate token count in the API response, so you know why you're getting additional input tokens beyond your initial prompt.
+
+
+
+## Limitations
+
+  * The model can only generate and execute code. It can't return other artifacts like media files.
+  * In some cases, enabling code execution can lead to regressions in other areas of model output (for example, writing a story).
+  * There is some variation in the ability of the different models to use code execution successfully.
+
+
+
+## Supported libraries
+
+The code execution environment includes the following libraries:
+
+  * attrs
+  * chess
+  * contourpy
+  * fpdf
+  * geopandas
+  * imageio
+  * jinja2
+  * joblib
+  * jsonschema
+  * jsonschema-specifications
+  * lxml
+  * matplotlib
+  * mpmath
+  * numpy
+  * opencv-python
+  * openpyxl
+  * packaging
+  * pandas
+  * pillow
+  * protobuf
+  * pylatex
+  * pyparsing
+  * PyPDF2
+  * python-dateutil
+  * python-docx
+  * python-pptx
+  * reportlab
+  * scikit-learn
+  * scipy
+  * seaborn
+  * six
+  * striprtf
+  * sympy
+  * tabulate
+  * tensorflow
+  * toolz
+  * xlrd
+
+
+
+You can't install your own libraries.
+
+**Note:** Only `matplotlib` is supported for graph rendering using code execution.
+
+## What's next
+
+  * Try the [code execution Colab](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Code_Execution.ipynb).
+  * Learn about other Gemini API tools: 
+    * [Function calling](/gemini-api/docs/function-calling)
+    * [Grounding with Google Search](/gemini-api/docs/grounding)
+
+

documentation_gemini/document_understanding.md

@@ -0,0 +1,215 @@
+# Document understanding
+
+Source: <https://ai.google.dev/gemini-api/docs/document-processing>
+
+---
+
+Gemini models can process documents in PDF format, using native vision to understand entire document contexts. This goes beyond simple text extraction, allowing Gemini to:
+
+  * Analyze and interpret content, including text, images, diagrams, charts, and tables, even in long documents up to 1000 pages.
+  * Extract information into [structured output](/gemini-api/docs/structured-output) formats.
+  * Summarize and answer questions based on both the visual and textual elements in a document.
+  * Transcribe document content (e.g. to HTML), preserving layouts and formatting, for use in downstream applications.
+
+
+
+## Passing inline PDF data
+
+You can pass inline PDF data in the request to `generateContent`. For PDF payloads under 20MB, you can choose between uploading base64 encoded documents or directly uploading locally stored files.
+
+The following example shows you how to fetch a PDF from a URL and convert it to bytes for processing:
+    
+    
+    from google import genai
+    from google.genai import types
+    import httpx
+    
+    client = genai.Client()
+    
+    doc_url = "https://discovery.ucl.ac.uk/id/eprint/10089234/1/343019_3_art_0_py4t4l_convrt.pdf"
+    
+    # Retrieve and encode the PDF byte
+    doc_data = httpx.get(doc_url).content
+    
+    prompt = "Summarize this document"
+    response = client.models.generate_content(
+      model="gemini-2.5-flash",
+      contents=[
+          types.Part.from_bytes(
+            data=doc_data,
+            mime_type='application/pdf',
+          ),
+          prompt])
+    print(response.text)
+    
+
+You can also read a PDF from a local file for processing:
+    
+    
+    from google import genai
+    from google.genai import types
+    import pathlib
+    
+    client = genai.Client()
+    
+    # Retrieve and encode the PDF byte
+    filepath = pathlib.Path('file.pdf')
+    
+    prompt = "Summarize this document"
+    response = client.models.generate_content(
+      model="gemini-2.5-flash",
+      contents=[
+          types.Part.from_bytes(
+            data=filepath.read_bytes(),
+            mime_type='application/pdf',
+          ),
+          prompt])
+    print(response.text)
+    
+
+## Uploading PDFs using the File API
+
+You can use the [File API](/gemini-api/docs/files) to upload larger documents. Always use the File API when the total request size (including the files, text prompt, system instructions, etc.) is larger than 20MB.
+
+**Note:** The [File API](/gemini-api/docs/files) lets you store up to 50MB of PDF files. Files are stored for 48 hours. You can access them in that period with your API key, but you can't download them from the API. The File API is available at no cost in all regions where the Gemini API is available.
+
+Call [`media.upload`](/api/rest/v1beta/media/upload) to upload a file using the File API. The following code uploads a document file and then uses the file in a call to [`models.generateContent`](/api/generate-content#method:-models.generatecontent).
+
+### Large PDFs from URLs
+
+Use the File API to simplify uploading and processing large PDF files from URLs:
+    
+    
+    from google import genai
+    from google.genai import types
+    import io
+    import httpx
+    
+    client = genai.Client()
+    
+    long_context_pdf_path = "https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf"
+    
+    # Retrieve and upload the PDF using the File API
+    doc_io = io.BytesIO(httpx.get(long_context_pdf_path).content)
+    
+    sample_doc = client.files.upload(
+      # You can pass a path or a file-like object here
+      file=doc_io,
+      config=dict(
+        mime_type='application/pdf')
+    )
+    
+    prompt = "Summarize this document"
+    
+    response = client.models.generate_content(
+      model="gemini-2.5-flash",
+      contents=[sample_doc, prompt])
+    print(response.text)
+    
+
+### Large PDFs stored locally
+    
+    
+    from google import genai
+    from google.genai import types
+    import pathlib
+    import httpx
+    
+    client = genai.Client()
+    
+    # Retrieve and encode the PDF byte
+    file_path = pathlib.Path('large_file.pdf')
+    
+    # Upload the PDF using the File API
+    sample_file = client.files.upload(
+      file=file_path,
+    )
+    
+    prompt="Summarize this document"
+    
+    response = client.models.generate_content(
+      model="gemini-2.5-flash",
+      contents=[sample_file, "Summarize this document"])
+    print(response.text)
+    
+
+You can verify the API successfully stored the uploaded file and get its metadata by calling [`files.get`](/api/rest/v1beta/files/get). Only the `name` (and by extension, the `uri`) are unique.
+    
+    
+    from google import genai
+    import pathlib
+    
+    client = genai.Client()
+    
+    fpath = pathlib.Path('example.txt')
+    fpath.write_text('hello')
+    
+    file = client.files.upload(file='example.txt')
+    
+    file_info = client.files.get(name=file.name)
+    print(file_info.model_dump_json(indent=4))
+    
+
+## Passing multiple PDFs
+
+The Gemini API is capable of processing multiple PDF documents (up to 1000 pages) in a single request, as long as the combined size of the documents and the text prompt stays within the model's context window.
+    
+    
+    from google import genai
+    import io
+    import httpx
+    
+    client = genai.Client()
+    
+    doc_url_1 = "https://arxiv.org/pdf/2312.11805"
+    doc_url_2 = "https://arxiv.org/pdf/2403.05530"
+    
+    # Retrieve and upload both PDFs using the File API
+    doc_data_1 = io.BytesIO(httpx.get(doc_url_1).content)
+    doc_data_2 = io.BytesIO(httpx.get(doc_url_2).content)
+    
+    sample_pdf_1 = client.files.upload(
+      file=doc_data_1,
+      config=dict(mime_type='application/pdf')
+    )
+    sample_pdf_2 = client.files.upload(
+      file=doc_data_2,
+      config=dict(mime_type='application/pdf')
+    )
+    
+    prompt = "What is the difference between each of the main benchmarks between these two papers? Output these in a table."
+    
+    response = client.models.generate_content(
+      model="gemini-2.5-flash",
+      contents=[sample_pdf_1, sample_pdf_2, prompt])
+    print(response.text)
+    
+
+## Technical details
+
+Gemini supports a maximum of 1,000 document pages. Each document page is equivalent to 258 tokens.
+
+While there are no specific limits to the number of pixels in a document besides the model's [context window](/gemini-api/docs/long-context), larger pages are scaled down to a maximum resolution of 3072x3072 while preserving their original aspect ratio, while smaller pages are scaled up to 768x768 pixels. There is no cost reduction for pages at lower sizes, other than bandwidth, or performance improvement for pages at higher resolution.
+
+### Document types
+
+Technically, you can pass other MIME types for document understanding, like TXT, Markdown, HTML, XML, etc. However, document vision **_only meaningfully understands PDFs_**. Other types will be extracted as pure text, and the model won't be able to interpret what we see in the rendering of those files. Any file-type specifics like charts, diagrams, HTML tags, Markdown formatting, etc., will be lost.
+
+### Best practices
+
+For best results:
+
+  * Rotate pages to the correct orientation before uploading.
+  * Avoid blurry pages.
+  * If using a single page, place the text prompt after the page.
+
+
+
+## What's next
+
+To learn more, see the following resources:
+
+  * [File prompting strategies](/gemini-api/docs/files#prompt-guide): The Gemini API supports prompting with text, image, audio, and video data, also known as multimodal prompting.
+  * [System instructions](/gemini-api/docs/text-generation#system-instructions): System instructions let you steer the behavior of the model based on your specific needs and use cases.
+
+

documentation_gemini/function_calling_with_the_gemini_api.md

@@ -0,0 +1,674 @@
+# Function calling with the Gemini API
+
+Source: <https://ai.google.dev/gemini-api/docs/function-calling>
+
+---
+
+Function calling lets you connect models to external tools and APIs. Instead of generating text responses, the model determines when to call specific functions and provides the necessary parameters to execute real-world actions. This allows the model to act as a bridge between natural language and real-world actions and data. Function calling has 3 primary use cases:
+
+  * **Augment Knowledge:** Access information from external sources like databases, APIs, and knowledge bases.
+  * **Extend Capabilities:** Use external tools to perform computations and extend the limitations of the model, such as using a calculator or creating charts.
+  * **Take Actions:** Interact with external systems using APIs, such as scheduling appointments, creating invoices, sending emails, or controlling smart home devices.
+
+
+
+Get Weather Schedule Meeting Create Chart
+
+## How function calling works
+
+![function calling
+overview](/static/gemini-api/docs/images/function-calling-overview.png)
+
+Function calling involves a structured interaction between your application, the model, and external functions. Here's a breakdown of the process:
+
+  1. **Define Function Declaration:** Define the function declaration in your application code. Function Declarations describe the function's name, parameters, and purpose to the model.
+  2. **Call LLM with function declarations:** Send user prompt along with the function declaration(s) to the model. It analyzes the request and determines if a function call would be helpful. If so, it responds with a structured JSON object.
+  3. **Execute Function Code (Your Responsibility):** The Model _does not_ execute the function itself. It's your application's responsibility to process the response and check for Function Call, if 
+     * **Yes** : Extract the name and args of the function and execute the corresponding function in your application.
+     * **No:** The model has provided a direct text response to the prompt (this flow is less emphasized in the example but is a possible outcome).
+  4. **Create User friendly response:** If a function was executed, capture the result and send it back to the model in a subsequent turn of the conversation. It will use the result to generate a final, user-friendly response that incorporates the information from the function call.
+
+
+
+This process can be repeated over multiple turns, allowing for complex interactions and workflows. The model also supports calling multiple functions in a single turn ([parallel function calling](/gemini-api/docs/function-calling#parallel_function_calling)) and in sequence ([compositional function calling](/gemini-api/docs/function-calling#compositional_function_calling)).
+
+### Step 1: Define a function declaration
+
+Define a function and its declaration within your application code that allows users to set light values and make an API request. This function could call external services or APIs.
+    
+    
+    # Define a function that the model can call to control smart lights
+    set_light_values_declaration = {
+        "name": "set_light_values",
+        "description": "Sets the brightness and color temperature of a light.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "brightness": {
+                    "type": "integer",
+                    "description": "Light level from 0 to 100. Zero is off and 100 is full brightness",
+                },
+                "color_temp": {
+                    "type": "string",
+                    "enum": ["daylight", "cool", "warm"],
+                    "description": "Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.",
+                },
+            },
+            "required": ["brightness", "color_temp"],
+        },
+    }
+    
+    # This is the actual function that would be called based on the model's suggestion
+    def set_light_values(brightness: int, color_temp: str) -> dict[str, int | str]:
+        """Set the brightness and color temperature of a room light. (mock API).
+    
+        Args:
+            brightness: Light level from 0 to 100. Zero is off and 100 is full brightness
+            color_temp: Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.
+    
+        Returns:
+            A dictionary containing the set brightness and color temperature.
+        """
+        return {"brightness": brightness, "colorTemperature": color_temp}
+    
+
+### Step 2: Call the model with function declarations
+
+Once you have defined your function declarations, you can prompt the model to use them. It analyzes the prompt and function declarations and decides whether to respond directly or to call a function. If a function is called, the response object will contain a function call suggestion.
+    
+    
+    from google.genai import types
+    
+    # Configure the client and tools
+    client = genai.Client()
+    tools = types.Tool(function_declarations=[set_light_values_declaration])
+    config = types.GenerateContentConfig(tools=[tools])
+    
+    # Define user prompt
+    contents = [
+        types.Content(
+            role="user", parts=[types.Part(text="Turn the lights down to a romantic level")]
+        )
+    ]
+    
+    # Send request with function declarations
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=contents
+        config=config,
+    )
+    
+    print(response.candidates[0].content.parts[0].function_call)
+    
+
+The model then returns a `functionCall` object in an OpenAPI compatible schema specifying how to call one or more of the declared functions in order to respond to the user's question.
+    
+    
+    id=None args={'color_temp': 'warm', 'brightness': 25} name='set_light_values'
+    
+
+### Step 3: Execute set_light_values function code
+
+Extract the function call details from the model's response, parse the arguments , and execute the `set_light_values` function.
+    
+    
+    # Extract tool call details, it may not be in the first part.
+    tool_call = response.candidates[0].content.parts[0].function_call
+    
+    if tool_call.name == "set_light_values":
+        result = set_light_values(**tool_call.args)
+        print(f"Function execution result: {result}")
+    
+
+### Step 4: Create user friendly response with function result and call the model again
+
+Finally, send the result of the function execution back to the model so it can incorporate this information into its final response to the user.
+    
+    
+    # Create a function response part
+    function_response_part = types.Part.from_function_response(
+        name=tool_call.name,
+        response={"result": result},
+    )
+    
+    # Append function call and result of the function execution to contents
+    contents.append(response.candidates[0].content) # Append the content from the model's response.
+    contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response
+    
+    final_response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        config=config,
+        contents=contents,
+    )
+    
+    print(final_response.text)
+    
+
+This completes the function calling flow. The model successfully used the `set_light_values` function to perform the request action of the user.
+
+## Function declarations
+
+When you implement function calling in a prompt, you create a `tools` object, which contains one or more `function declarations`. You define functions using JSON, specifically with a [select subset](https://ai.google.dev/api/caching#Schema) of the [OpenAPI schema](https://spec.openapis.org/oas/v3.0.3#schemaw) format. A single function declaration can include the following parameters:
+
+  * `name` (string): A unique name for the function (`get_weather_forecast`, `send_email`). Use descriptive names without spaces or special characters (use underscores or camelCase).
+  * `description` (string): A clear and detailed explanation of the function's purpose and capabilities. This is crucial for the model to understand when to use the function. Be specific and provide examples if helpful ("Finds theaters based on location and optionally movie title which is currently playing in theaters.").
+  * `parameters` (object): Defines the input parameters the function expects. 
+    * `type` (string): Specifies the overall data type, such as `object`.
+    * `properties` (object): Lists individual parameters, each with: 
+      * `type` (string): The data type of the parameter, such as `string`, `integer`, `boolean, array`.
+      * `description` (string): A description of the parameter's purpose and format. Provide examples and constraints ("The city and state, e.g., 'San Francisco, CA' or a zip code e.g., '95616'.").
+      * `enum` (array, optional): If the parameter values are from a fixed set, use "enum" to list the allowed values instead of just describing them in the description. This improves accuracy ("enum": ["daylight", "cool", "warm"]).
+    * `required` (array): An array of strings listing the parameter names that are mandatory for the function to operate.
+
+
+
+You can also construct FunctionDeclarations from Python functions directly using `types.FunctionDeclaration.from_callable(client=client, callable=your_function)`.
+
+## Function calling with thinking
+
+Enabling "[thinking](/gemini-api/docs/thinking)" can improve function call performance by allowing the model to reason through a request before suggesting function calls. The Gemini API is stateless, the model's reasoning context will be lost between turns in a multi-turn conversation. To preserve this context, you can use thought signatures. A thought signature is an encrypted representation of the model's internal thought process that you pass back to the model on subsequent turns.
+
+The [standard pattern for multi-turn tool](/gemini-api/docs/function-calling?example=weather#step-4) use is to append the model's complete previous response to the conversation history. The `content` object includes the `thought_signatures` automatically. If you follow this pattern **No code changes are required**.
+
+### Manually managing thought signatures
+
+If you modify the conversation history manually—instead of sending the complete previous response and want to benefit from thinking you must correctly handle the `thought_signature` included in the model's turn.
+
+Follow these rules to ensure the model's context is preserved:
+
+  * Always send the `thought_signature` back to the model inside its original `Part`.
+  * Don't merge a `Part` containing a signature with one that does not. This breaks the positional context of the thought.
+  * Don't combine two `Parts` that both contain signatures, as the signature strings cannot be merged.
+
+
+
+### Inspecting Thought Signatures
+
+While not necessary for implementation, you can inspect the response to see the `thought_signature` for debugging or educational purposes.
+    
+    
+    import base64
+    # After receiving a response from a model with thinking enabled
+    # response = client.models.generate_content(...)
+    
+    # The signature is attached to the response part containing the function call
+    part = response.candidates[0].content.parts[0]
+    if part.thought_signature:
+      print(base64.b64encode(part.thought_signature).decode("utf-8"))
+    
+
+Learn more about limitations and usage of thought signatures, and about thinking models in general, on the [Thinking](/gemini-api/docs/thinking#signatures) page.
+
+## Parallel function calling
+
+In addition to single turn function calling, you can also call multiple functions at once. Parallel function calling lets you execute multiple functions at once and is used when the functions are not dependent on each other. This is useful in scenarios like gathering data from multiple independent sources, such as retrieving customer details from different databases or checking inventory levels across various warehouses or performing multiple actions such as converting your apartment into a disco.
+    
+    
+    power_disco_ball = {
+        "name": "power_disco_ball",
+        "description": "Powers the spinning disco ball.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "power": {
+                    "type": "boolean",
+                    "description": "Whether to turn the disco ball on or off.",
+                }
+            },
+            "required": ["power"],
+        },
+    }
+    
+    start_music = {
+        "name": "start_music",
+        "description": "Play some music matching the specified parameters.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "energetic": {
+                    "type": "boolean",
+                    "description": "Whether the music is energetic or not.",
+                },
+                "loud": {
+                    "type": "boolean",
+                    "description": "Whether the music is loud or not.",
+                },
+            },
+            "required": ["energetic", "loud"],
+        },
+    }
+    
+    dim_lights = {
+        "name": "dim_lights",
+        "description": "Dim the lights.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "brightness": {
+                    "type": "number",
+                    "description": "The brightness of the lights, 0.0 is off, 1.0 is full.",
+                }
+            },
+            "required": ["brightness"],
+        },
+    }
+    
+
+Configure the function calling mode to allow using all of the specified tools. To learn more, you can read about [configuring function calling](/gemini-api/docs/function-calling#function_calling_modes).
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    # Configure the client and tools
+    client = genai.Client()
+    house_tools = [
+        types.Tool(function_declarations=[power_disco_ball, start_music, dim_lights])
+    ]
+    config = types.GenerateContentConfig(
+        tools=house_tools,
+        automatic_function_calling=types.AutomaticFunctionCallingConfig(
+            disable=True
+        ),
+        # Force the model to call 'any' function, instead of chatting.
+        tool_config=types.ToolConfig(
+            function_calling_config=types.FunctionCallingConfig(mode='ANY')
+        ),
+    )
+    
+    chat = client.chats.create(model="gemini-2.5-flash", config=config)
+    response = chat.send_message("Turn this place into a party!")
+    
+    # Print out each of the function calls requested from this single call
+    print("Example 1: Forced function calling")
+    for fn in response.function_calls:
+        args = ", ".join(f"{key}={val}" for key, val in fn.args.items())
+        print(f"{fn.name}({args})")
+    
+
+Each of the printed results reflects a single function call that the model has requested. To send the results back, include the responses in the same order as they were requested.
+
+The Python SDK supports [automatic function calling](/gemini-api/docs/function-calling#automatic_function_calling_python_only), which automatically converts Python functions to declarations, handles the function call execution and response cycle for you. Following is an example for the disco use case.
+
+**Note:** Automatic Function Calling is a Python SDK only feature at the moment.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    # Actual function implementations
+    def power_disco_ball_impl(power: bool) -> dict:
+        """Powers the spinning disco ball.
+    
+        Args:
+            power: Whether to turn the disco ball on or off.
+    
+        Returns:
+            A status dictionary indicating the current state.
+        """
+        return {"status": f"Disco ball powered {'on' if power else 'off'}"}
+    
+    def start_music_impl(energetic: bool, loud: bool) -> dict:
+        """Play some music matching the specified parameters.
+    
+        Args:
+            energetic: Whether the music is energetic or not.
+            loud: Whether the music is loud or not.
+    
+        Returns:
+            A dictionary containing the music settings.
+        """
+        music_type = "energetic" if energetic else "chill"
+        volume = "loud" if loud else "quiet"
+        return {"music_type": music_type, "volume": volume}
+    
+    def dim_lights_impl(brightness: float) -> dict:
+        """Dim the lights.
+    
+        Args:
+            brightness: The brightness of the lights, 0.0 is off, 1.0 is full.
+    
+        Returns:
+            A dictionary containing the new brightness setting.
+        """
+        return {"brightness": brightness}
+    
+    # Configure the client
+    client = genai.Client()
+    config = types.GenerateContentConfig(
+        tools=[power_disco_ball_impl, start_music_impl, dim_lights_impl]
+    )
+    
+    # Make the request
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="Do everything you need to this place into party!",
+        config=config,
+    )
+    
+    print("\nExample 2: Automatic function calling")
+    print(response.text)
+    # I've turned on the disco ball, started playing loud and energetic music, and dimmed the lights to 50% brightness. Let's get this party started!
+    
+
+## Compositional function calling
+
+Compositional or sequential function calling allows Gemini to chain multiple function calls together to fulfill a complex request. For example, to answer "Get the temperature in my current location", the Gemini API might first invoke a `get_current_location()` function followed by a `get_weather()` function that takes the location as a parameter.
+
+The following example demonstrates how to implement compositional function calling using the Python SDK and automatic function calling.
+
+This example uses the automatic function calling feature of the `google-genai` Python SDK. The SDK automatically converts the Python functions to the required schema, executes the function calls when requested by the model, and sends the results back to the model to complete the task.
+    
+    
+    import os
+    from google import genai
+    from google.genai import types
+    
+    # Example Functions
+    def get_weather_forecast(location: str) -> dict:
+        """Gets the current weather temperature for a given location."""
+        print(f"Tool Call: get_weather_forecast(location={location})")
+        # TODO: Make API call
+        print("Tool Response: {'temperature': 25, 'unit': 'celsius'}")
+        return {"temperature": 25, "unit": "celsius"}  # Dummy response
+    
+    def set_thermostat_temperature(temperature: int) -> dict:
+        """Sets the thermostat to a desired temperature."""
+        print(f"Tool Call: set_thermostat_temperature(temperature={temperature})")
+        # TODO: Interact with a thermostat API
+        print("Tool Response: {'status': 'success'}")
+        return {"status": "success"}
+    
+    # Configure the client and model
+    client = genai.Client()
+    config = types.GenerateContentConfig(
+        tools=[get_weather_forecast, set_thermostat_temperature]
+    )
+    
+    # Make the request
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="If it's warmer than 20°C in London, set the thermostat to 20°C, otherwise set it to 18°C.",
+        config=config,
+    )
+    
+    # Print the final, user-facing response
+    print(response.text)
+    
+
+**Expected Output**
+
+When you run the code, you will see the SDK orchestrating the function calls. The model first calls `get_weather_forecast`, receives the temperature, and then calls `set_thermostat_temperature` with the correct value based on the logic in the prompt.
+    
+    
+    Tool Call: get_weather_forecast(location=London)
+    Tool Response: {'temperature': 25, 'unit': 'celsius'}
+    Tool Call: set_thermostat_temperature(temperature=20)
+    Tool Response: {'status': 'success'}
+    OK. I've set the thermostat to 20°C.
+    
+
+Compositional function calling is a native [Live API](https://ai.google.dev/gemini-api/docs/live) feature. This means Live API can handle the function calling similar to the Python SDK.
+    
+    
+    # Light control schemas
+    turn_on_the_lights_schema = {'name': 'turn_on_the_lights'}
+    turn_off_the_lights_schema = {'name': 'turn_off_the_lights'}
+    
+    prompt = """
+      Hey, can you write run some python code to turn on the lights, wait 10s and then turn off the lights?
+      """
+    
+    tools = [
+        {'code_execution': {}},
+        {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]}
+    ]
+    
+    await run(prompt, tools=tools, modality="AUDIO")
+    
+
+## Function calling modes
+
+The Gemini API lets you control how the model uses the provided tools (function declarations). Specifically, you can set the mode within the.`function_calling_config`.
+
+  * `AUTO (Default)`: The model decides whether to generate a natural language response or suggest a function call based on the prompt and context. This is the most flexible mode and recommended for most scenarios.
+  * `ANY`: The model is constrained to always predict a function call and guarantees function schema adherence. If `allowed_function_names` is not specified, the model can choose from any of the provided function declarations. If `allowed_function_names` is provided as a list, the model can only choose from the functions in that list. Use this mode when you require a function call response to every prompt (if applicable).
+  * `NONE`: The model is _prohibited_ from making function calls. This is equivalent to sending a request without any function declarations. Use this to temporarily disable function calling without removing your tool definitions.
+
+
+
+    
+    
+    from google.genai import types
+    
+    # Configure function calling mode
+    tool_config = types.ToolConfig(
+        function_calling_config=types.FunctionCallingConfig(
+            mode="ANY", allowed_function_names=["get_current_temperature"]
+        )
+    )
+    
+    # Create the generation config
+    config = types.GenerateContentConfig(
+        tools=[tools],  # not defined here.
+        tool_config=tool_config,
+    )
+    
+
+## Automatic function calling (Python only)
+
+When using the Python SDK, you can provide Python functions directly as tools. The SDK converts these functions into declarations, manages the function call execution, and handles the response cycle for you. Define your function with type hints and a docstring. For optimal results, it is recommended to use [Google-style docstrings.](https://google.github.io/styleguide/pyguide.html#383-functions-and-methods) The SDK will then automatically:
+
+  1. Detect function call responses from the model.
+  2. Call the corresponding Python function in your code.
+  3. Send the function's response back to the model.
+  4. Return the model's final text response.
+
+
+
+The SDK currently does not parse argument descriptions into the property description slots of the generated function declaration. Instead, it sends the entire docstring as the top-level function description.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    # Define the function with type hints and docstring
+    def get_current_temperature(location: str) -> dict:
+        """Gets the current temperature for a given location.
+    
+        Args:
+            location: The city and state, e.g. San Francisco, CA
+    
+        Returns:
+            A dictionary containing the temperature and unit.
+        """
+        # ... (implementation) ...
+        return {"temperature": 25, "unit": "Celsius"}
+    
+    # Configure the client
+    client = genai.Client()
+    config = types.GenerateContentConfig(
+        tools=[get_current_temperature]
+    )  # Pass the function itself
+    
+    # Make the request
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="What's the temperature in Boston?",
+        config=config,
+    )
+    
+    print(response.text)  # The SDK handles the function call and returns the final text
+    
+
+You can disable automatic function calling with:
+    
+    
+    config = types.GenerateContentConfig(
+        tools=[get_current_temperature],
+        automatic_function_calling=types.AutomaticFunctionCallingConfig(disable=True)
+    )
+    
+
+### Automatic function schema declaration
+
+The API is able to describe any of the following types. `Pydantic` types are allowed, as long as the fields defined on them are also composed of allowed types. Dict types (like `dict[str: int]`) are not well supported here, don't use them.
+    
+    
+    AllowedType = (
+      int | float | bool | str | list['AllowedType'] | pydantic.BaseModel)
+    
+
+To see what the inferred schema looks like, you can convert it using [`from_callable`](https://googleapis.github.io/python-genai/genai.html#genai.types.FunctionDeclaration.from_callable):
+    
+    
+    def multiply(a: float, b: float):
+        """Returns a * b."""
+        return a * b
+    
+    fn_decl = types.FunctionDeclaration.from_callable(callable=multiply, client=client)
+    
+    # to_json_dict() provides a clean JSON representation.
+    print(fn_decl.to_json_dict())
+    
+
+## Multi-tool use: Combine native tools with function calling
+
+You can enable multiple tools combining native tools with function calling at the same time. Here's an example that enables two tools, [Grounding with Google Search](/gemini-api/docs/grounding) and [code execution](/gemini-api/docs/code-execution), in a request using the [Live API](/gemini-api/docs/live).
+
+**Note:** Multi-tool use is a-[Live API](https://ai.google.dev/gemini-api/docs/live) only feature at the moment. The `run()` function declaration, which handles the asynchronous websocket setup, is omitted for brevity.
+    
+    
+    # Multiple tasks example - combining lights, code execution, and search
+    prompt = """
+      Hey, I need you to do three things for me.
+    
+        1.  Turn on the lights.
+        2.  Then compute the largest prime palindrome under 100000.
+        3.  Then use Google Search to look up information about the largest earthquake in California the week of Dec 5 2024.
+    
+      Thanks!
+      """
+    
+    tools = [
+        {'google_search': {}},
+        {'code_execution': {}},
+        {'function_declarations': [turn_on_the_lights_schema, turn_off_the_lights_schema]} # not defined here.
+    ]
+    
+    # Execute the prompt with specified tools in audio modality
+    await run(prompt, tools=tools, modality="AUDIO")
+    
+
+Python developers can try this out in the [Live API Tool Use notebook](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_LiveAPI_tools.ipynb).
+
+## Model context protocol (MCP)
+
+[Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is an open standard for connecting AI applications with external tools and data. MCP provides a common protocol for models to access context, such as functions (tools), data sources (resources), or predefined prompts.
+
+The Gemini SDKs have built-in support for the MCP, reducing boilerplate code and offering [automatic tool calling](/gemini-api/docs/function-calling#automatic_function_calling_python_only) for MCP tools. When the model generates an MCP tool call, the Python and JavaScript client SDK can automatically execute the MCP tool and send the response back to the model in a subsequent request, continuing this loop until no more tool calls are made by the model.
+
+Here, you can find an example of how to use a local MCP server with Gemini and `mcp` SDK.
+
+Make sure the latest version of the [`mcp` SDK](https://modelcontextprotocol.io/introduction) is installed on your platform of choice.
+    
+    
+    pip install mcp
+    
+
+**Note:** Python supports automatic tool calling by passing in the `ClientSession` into the `tools` parameters. If you want to disable it, you can provide `automatic_function_calling` with disabled `True`.
+    
+    
+    import os
+    import asyncio
+    from datetime import datetime
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    from google import genai
+    
+    client = genai.Client()
+    
+    # Create server parameters for stdio connection
+    server_params = StdioServerParameters(
+        command="npx",  # Executable
+        args=["-y", "@philschmid/weather-mcp"],  # MCP Server
+        env=None,  # Optional environment variables
+    )
+    
+    async def run():
+        async with stdio_client(server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                # Prompt to get the weather for the current day in London.
+                prompt = f"What is the weather in London in {datetime.now().strftime('%Y-%m-%d')}?"
+    
+                # Initialize the connection between client and server
+                await session.initialize()
+    
+                # Send request to the model with MCP function declarations
+                response = await client.aio.models.generate_content(
+                    model="gemini-2.5-flash",
+                    contents=prompt,
+                    config=genai.types.GenerateContentConfig(
+                        temperature=0,
+                        tools=[session],  # uses the session, will automatically call the tool
+                        # Uncomment if you **don't** want the SDK to automatically call the tool
+                        # automatic_function_calling=genai.types.AutomaticFunctionCallingConfig(
+                        #     disable=True
+                        # ),
+                    ),
+                )
+                print(response.text)
+    
+    # Start the asyncio event loop and run the main function
+    asyncio.run(run())
+    
+
+### Limitations with built-in MCP support
+
+Built-in MCP support is a [experimental](/gemini-api/docs/models#preview) feature in our SDKs and has the following limitations:
+
+  * Only tools are supported, not resources nor prompts
+  * It is available for the Python and JavaScript/TypeScript SDK.
+  * Breaking changes might occur in future releases.
+
+
+
+Manual integration of MCP servers is always an option if these limit what you're building.
+
+## Supported models
+
+This section lists models and their function calling capabilities. Experimental models are not included. You can find a comprehensive capabilities overview on the [model overview](https://ai.google.dev/gemini-api/docs/models) page.
+
+Model | Function Calling | Parallel Function Calling | Compositional Function Calling  
+---|---|---|---  
+Gemini 2.5 Pro | ✔️ | ✔️ | ✔️  
+Gemini 2.5 Flash | ✔️ | ✔️ | ✔️  
+Gemini 2.5 Flash-Lite | ✔️ | ✔️ | ✔️  
+Gemini 2.0 Flash | ✔️ | ✔️ | ✔️  
+Gemini 2.0 Flash-Lite | X | X | X  
+  
+## Best practices
+
+  * **Function and Parameter Descriptions:** Be extremely clear and specific in your descriptions. The model relies on these to choose the correct function and provide appropriate arguments.
+  * **Naming:** Use descriptive function names (without spaces, periods, or dashes).
+  * **Strong Typing:** Use specific types (integer, string, enum) for parameters to reduce errors. If a parameter has a limited set of valid values, use an enum.
+  * **Tool Selection:** While the model can use an arbitrary number of tools, providing too many can increase the risk of selecting an incorrect or suboptimal tool. For best results, aim to provide only the relevant tools for the context or task, ideally keeping the active set to a maximum of 10-20. Consider dynamic tool selection based on conversation context if you have a large total number of tools.
+  * **Prompt Engineering:**
+    * Provide context: Tell the model its role (e.g., "You are a helpful weather assistant.").
+    * Give instructions: Specify how and when to use functions (e.g., "Don't guess dates; always use a future date for forecasts.").
+    * Encourage clarification: Instruct the model to ask clarifying questions if needed.
+  * **Temperature:** Use a low temperature (e.g., 0) for more deterministic and reliable function calls.
+  * **Validation:** If a function call has significant consequences (e.g., placing an order), validate the call with the user before executing it.
+  * **Error Handling** : Implement robust error handling in your functions to gracefully handle unexpected inputs or API failures. Return informative error messages that the model can use to generate helpful responses to the user.
+  * **Security:** Be mindful of security when calling external APIs. Use appropriate authentication and authorization mechanisms. Avoid exposing sensitive data in function calls.
+  * **Token Limits:** Function descriptions and parameters count towards your input token limit. If you're hitting token limits, consider limiting the number of functions or the length of the descriptions, break down complex tasks into smaller, more focused function sets.
+
+
+
+## Notes and limitations
+
+  * Only a [subset of the OpenAPI schema](https://ai.google.dev/api/caching#FunctionDeclaration) is supported.
+  * Supported parameter types in Python are limited.
+  * Automatic function calling is a Python SDK feature only.
+
+

documentation_gemini/gemini_thinking.md

@@ -0,0 +1,260 @@
+# Gemini thinking
+
+Source: <https://ai.google.dev/gemini-api/docs/thinking>
+
+---
+
+The [Gemini 2.5 series models](/gemini-api/docs/models) use an internal "thinking process" that significantly improves their reasoning and multi-step planning abilities, making them highly effective for complex tasks such as coding, advanced mathematics, and data analysis.
+
+This guide shows you how to work with Gemini's thinking capabilities using the Gemini API.
+
+## Before you begin
+
+Ensure you use a supported 2.5 series model for thinking. You might find it beneficial to explore these models in AI Studio before diving into the API:
+
+  * [Try Gemini 2.5 Flash in AI Studio](https://aistudio.google.com/prompts/new_chat?model=gemini-2.5-flash)
+  * [Try Gemini 2.5 Pro in AI Studio](https://aistudio.google.com/prompts/new_chat?model=gemini-2.5-pro)
+  * [Try Gemini 2.5 Flash-Lite in AI Studio](https://aistudio.google.com/prompts/new_chat?model=gemini-2.5-flash-lite)
+
+
+
+## Generating content with thinking
+
+Initiating a request with a thinking model is similar to any other content generation request. The key difference lies in specifying one of the models with thinking support in the `model` field, as demonstrated in the following [text generation](/gemini-api/docs/text-generation#text-input) example:
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example."
+    response = client.models.generate_content(
+        model="gemini-2.5-pro",
+        contents=prompt
+    )
+    
+    print(response.text)
+    
+
+## Thinking budgets
+
+The `thinkingBudget` parameter guides the model on the number of thinking tokens to use when generating a response. A higher token count generally allows for more detailed reasoning, which can be beneficial for tackling more complex tasks. If latency is more important, use a lower budget or disable thinking by setting `thinkingBudget` to 0. Setting the `thinkingBudget` to -1 turns on **dynamic thinking** , meaning the model will adjust the budget based on the complexity of the request.
+
+The `thinkingBudget` is only supported in Gemini 2.5 Flash, 2.5 Pro, and 2.5 Flash-Lite. Depending on the prompt, the model might overflow or underflow the token budget.
+
+The following are `thinkingBudget` configuration details for each model type.
+
+Model | Default setting  
+(Thinking budget is not set) | Range | Disable thinking | Turn on dynamic thinking  
+---|---|---|---|---  
+**2.5 Pro** | Dynamic thinking: Model decides when and how much to think | `128` to `32768` | N/A: Cannot disable thinking | `thinkingBudget = -1`  
+**2.5 Flash** | Dynamic thinking: Model decides when and how much to think | `0` to `24576` | `thinkingBudget = 0` | `thinkingBudget = -1`  
+**2.5 Flash Lite** | Model does not think | `512` to `24576` | `thinkingBudget = 0` | `thinkingBudget = -1`  
+      
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-pro",
+        contents="Provide a list of 3 famous physicists and their key contributions",
+        config=types.GenerateContentConfig(
+            thinking_config=types.ThinkingConfig(thinking_budget=1024)
+            # Turn off thinking:
+            # thinking_config=types.ThinkingConfig(thinking_budget=0)
+            # Turn on dynamic thinking:
+            # thinking_config=types.ThinkingConfig(thinking_budget=-1)
+        ),
+    )
+    
+    print(response.text)
+    
+
+## Thought summaries
+
+Thought summaries are synthesized versions of the model's raw thoughts and offer insights into the model's internal reasoning process. Note that thinking budgets apply to the model's raw thoughts and not to thought summaries.
+
+You can enable thought summaries by setting `includeThoughts` to `true` in your request configuration. You can then access the summary by iterating through the `response` parameter's `parts`, and checking the `thought` boolean.
+
+Here's an example demonstrating how to enable and retrieve thought summaries without streaming, which returns a single, final thought summary with the response:
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    prompt = "What is the sum of the first 50 prime numbers?"
+    response = client.models.generate_content(
+      model="gemini-2.5-pro",
+      contents=prompt,
+      config=types.GenerateContentConfig(
+        thinking_config=types.ThinkingConfig(
+          include_thoughts=True
+        )
+      )
+    )
+    
+    for part in response.candidates[0].content.parts:
+      if not part.text:
+        continue
+      if part.thought:
+        print("Thought summary:")
+        print(part.text)
+        print()
+      else:
+        print("Answer:")
+        print(part.text)
+        print()
+    
+
+And here is an example using thinking with streaming, which returns rolling, incremental summaries during generation:
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    prompt = """
+    Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
+    The person who lives in the red house owns a cat.
+    Bob does not live in the green house.
+    Carol owns a dog.
+    The green house is to the left of the red house.
+    Alice does not own a cat.
+    Who lives in each house, and what pet do they own?
+    """
+    
+    thoughts = ""
+    answer = ""
+    
+    for chunk in client.models.generate_content_stream(
+        model="gemini-2.5-pro",
+        contents=prompt,
+        config=types.GenerateContentConfig(
+          thinking_config=types.ThinkingConfig(
+            include_thoughts=True
+          )
+        )
+    ):
+      for part in chunk.candidates[0].content.parts:
+        if not part.text:
+          continue
+        elif part.thought:
+          if not thoughts:
+            print("Thoughts summary:")
+          print(part.text)
+          thoughts += part.text
+        else:
+          if not answer:
+            print("Answer:")
+          print(part.text)
+          answer += part.text
+    
+
+## Thought signatures
+
+Because standard Gemini API text and content generation calls are stateless, when using thinking in multi-turn interactions (such as chat), the model doesn't have access to thought context from previous turns.
+
+You can maintain thought context using thought signatures, which are encrypted representations of the model's internal thought process. The model returns thought signatures in the response object when thinking and [function calling](/gemini-api/docs/function-calling#thinking) are enabled. To ensure the model maintains context across multiple turns of a conversation, you must provide the thought signatures back to the model in the subsequent requests.
+
+You will receive thought signatures when:
+
+  * Thinking is enabled and thoughts are generated.
+  * The request includes [function declarations](/gemini-api/docs/function-calling#step-2).
+
+**Note:** Thought signatures are only available when you're using function calling, specifically, your request must include [function declarations](/gemini-api/docs/function-calling#step-2).
+
+You can find an example of thinking with function calls on the [Function calling](/gemini-api/docs/function-calling#thinking) page.
+
+Other usage limitations to consider with function calling include:
+
+  * Signatures are returned from the model within other parts in the response, for example function calling or text parts. Return the entire response with all parts back to the model in subsequent turns.
+  * Don't concatenate parts with signatures together.
+  * Don't merge one part with a signature with another part without a signature.
+
+
+
+## Pricing
+
+**Note:** **Summaries** are available in the [free and paid tiers](/gemini-api/docs/pricing) of the API. **Thought signatures** will increase the input tokens you are charged when sent back as part of the request.
+
+When thinking is turned on, response pricing is the sum of output tokens and thinking tokens. You can get the total number of generated thinking tokens from the `thoughtsTokenCount` field.
+    
+    
+    # ...
+    print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
+    print("Output tokens:",response.usage_metadata.candidates_token_count)
+    
+
+Thinking models generate full thoughts to improve the quality of the final response, and then output summaries to provide insight into the thought process. So, pricing is based on the full thought tokens the model needs to generate to create a summary, despite only the summary being output from the API.
+
+You can learn more about tokens in the [Token counting](/gemini-api/docs/tokens) guide.
+
+## Supported models
+
+Thinking features are supported on all the 2.5 series models. You can find all model capabilities on the [model overview](/gemini-api/docs/models) page.
+
+## Best practices
+
+This section includes some guidance for using thinking models efficiently. As always, following our [prompting guidance and best practices](/gemini-api/docs/prompting-strategies) will get you the best results.
+
+### Debugging and steering
+
+  * **Review reasoning** : When you're not getting your expected response from the thinking models, it can help to carefully analyze Gemini's thought summaries. You can see how it broke down the task and arrived at its conclusion, and use that information to correct towards the right results.
+
+  * **Provide Guidance in Reasoning** : If you're hoping for a particularly lengthy output, you may want to provide guidance in your prompt to constrain the amount of thinking the model uses. This lets you reserve more of the token output for your response.
+
+
+
+
+### Task complexity
+
+  * **Easy Tasks (Thinking could be OFF):** For straightforward requests where complex reasoning isn't required, such as fact retrieval or classification, thinking is not required. Examples include: 
+    * "Where was DeepMind founded?"
+    * "Is this email asking for a meeting or just providing information?"
+  * **Medium Tasks (Default/Some Thinking):** Many common requests benefit from a degree of step-by-step processing or deeper understanding. Gemini can flexibly use thinking capability for tasks like: 
+    * Analogize photosynthesis and growing up.
+    * Compare and contrast electric cars and hybrid cars.
+  * **Hard Tasks (Maximum Thinking Capability):** For truly complex challenges, such as solving complex math problems or coding tasks, we recommend setting a high thinking budget. These types of tasks require the model to engage its full reasoning and planning capabilities, often involving many internal steps before providing an answer. Examples include: 
+    * Solve problem 1 in AIME 2025: Find the sum of all integer bases b > 9 for which 17b is a divisor of 97b.
+    * Write Python code for a web application that visualizes real-time stock market data, including user authentication. Make it as efficient as possible.
+
+
+
+## Thinking with tools and capabilities
+
+Thinking models work with all of Gemini's tools and capabilities. This allows the models to interact with external systems, execute code, or access real-time information, incorporating the results into their reasoning and final response.
+
+  * The [search tool](/gemini-api/docs/grounding) allows the model to query Google Search to find up-to-date information or information beyond its training data. This is useful for questions about recent events or highly specific topics.
+
+  * The [code execution tool](/gemini-api/docs/code-execution) enables the model to generate and run Python code to perform calculations, manipulate data, or solve problems that are best handled algorithmically. The model receives the code's output and can use it in its response.
+
+  * With [structured output](/gemini-api/docs/structured-output), you can constrain Gemini to respond with JSON. This is particularly useful for integrating the model's output into applications.
+
+  * [Function calling](/gemini-api/docs/function-calling) connects the thinking model to external tools and APIs, so it can reason about when to call the right function and what parameters to provide.
+
+  * [URL Context](/gemini-api/docs/url-context) provides the model with URLs as additional context for your prompt. The model can then retrieve content from the URLs and use that content to inform and shape its response.
+
+
+
+
+You can try examples of using tools with thinking models in the [Thinking cookbook](https://colab.sandbox.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_thinking.ipynb).
+
+## What's next?
+
+  * To work through more in depth examples, like:
+
+    * Using tools with thinking
+    * Streaming with thinking
+    * Adjusting the thinking budget for different results
+
+and more, try our [Thinking cookbook](https://colab.sandbox.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_thinking.ipynb).
+
+  * Thinking coverage is now available in our [OpenAI Compatibility](/gemini-api/docs/openai#thinking) guide.
+
+  * For more info about Gemini 2.5 Pro, Gemini Flash 2.5, and Gemini 2.5 Flash-Lite, visit the [model page](/gemini-api/docs/models).
+
+
+

documentation_gemini/grounding_with_google_search.md

@@ -0,0 +1,215 @@
+# Grounding with Google Search
+
+Source: <https://ai.google.dev/gemini-api/docs/google-search>
+
+---
+
+Grounding with Google Search connects the Gemini model to real-time web content and works with all [available languages](/gemini-api/docs/models/gemini#available-languages). This allows Gemini to provide more accurate answers and cite verifiable sources beyond its knowledge cutoff. 
+
+Grounding helps you build applications that can:
+
+  * **Increase factual accuracy:** Reduce model hallucinations by basing responses on real-world information.
+  * **Access real-time information:** Answer questions about recent events and topics.
+  * **Provide citations:** Build user trust by showing the sources for the model's claims.
+
+
+
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    # Configure the client
+    client = genai.Client()
+    
+    # Define the grounding tool
+    grounding_tool = types.Tool(
+        google_search=types.GoogleSearch()
+    )
+    
+    # Configure generation settings
+    config = types.GenerateContentConfig(
+        tools=[grounding_tool]
+    )
+    
+    # Make the request
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="Who won the euro 2024?",
+        config=config,
+    )
+    
+    # Print the grounded response
+    print(response.text)
+    
+
+You can learn more by trying the [Search tool notebook](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Search_Grounding.ipynb).
+
+## How grounding with Google Search works
+
+When you enable the `google_search` tool, the model handles the entire workflow of searching, processing, and citing information automatically.
+
+![grounding-overview](/static/gemini-api/docs/images/google-search-tool-overview.png)
+
+  1. **User Prompt:** Your application sends a user's prompt to the Gemini API with the `google_search` tool enabled.
+  2. **Prompt Analysis:** The model analyzes the prompt and determines if a Google Search can improve the answer.
+  3. **Google Search:** If needed, the model automatically generates one or multiple search queries and executes them.
+  4. **Search Results Processing:** The model processes the search results, synthesizes the information, and formulates a response.
+  5. **Grounded Response:** The API returns a final, user-friendly response that is grounded in the search results. This response includes the model's text answer and `groundingMetadata` with the search queries, web results, and citations.
+
+
+
+## Understanding the Grounding Response
+
+When a response is successfully grounded, the response includes a `groundingMetadata` field. This structured data is essential for verifying claims and building a rich citation experience in your application.
+    
+    
+    {
+      "candidates": [
+        {
+          "content": {
+            "parts": [
+              {
+                "text": "Spain won Euro 2024, defeating England 2-1 in the final. This victory marks Spain's record fourth European Championship title."
+              }
+            ],
+            "role": "model"
+          },
+          "groundingMetadata": {
+            "webSearchQueries": [
+              "UEFA Euro 2024 winner",
+              "who won euro 2024"
+            ],
+            "searchEntryPoint": {
+              "renderedContent": "<!-- HTML and CSS for the search widget -->"
+            },
+            "groundingChunks": [
+              {"web": {"uri": "https://vertexaisearch.cloud.google.com.....", "title": "aljazeera.com"}},
+              {"web": {"uri": "https://vertexaisearch.cloud.google.com.....", "title": "uefa.com"}}
+            ],
+            "groundingSupports": [
+              {
+                "segment": {"startIndex": 0, "endIndex": 85, "text": "Spain won Euro 2024, defeatin..."},
+                "groundingChunkIndices": [0]
+              },
+              {
+                "segment": {"startIndex": 86, "endIndex": 210, "text": "This victory marks Spain's..."},
+                "groundingChunkIndices": [0, 1]
+              }
+            ]
+          }
+        }
+      ]
+    }
+    
+
+The Gemini API returns the following information with the `groundingMetadata`:
+
+  * `webSearchQueries` : Array of the search queries used. This is useful for debugging and understanding the model's reasoning process.
+  * `searchEntryPoint` : Contains the HTML and CSS to render the required Search Suggestions. Full usage requirements are detailed in the [Terms of Service](/gemini-api/terms#grounding-with-google-search).
+  * `groundingChunks` : Array of objects containing the web sources (`uri` and `title`). 
+  * `groundingSupports` : Array of chunks to connect model response `text` to the sources in `groundingChunks`. Each chunk links a text `segment` (defined by `startIndex` and `endIndex`) to one or more `groundingChunkIndices`. This is the key to building inline citations.
+
+
+
+Grounding with Google Search can also be used in combination with the [URL context tool](/gemini-api/docs/url-context) to ground responses in both public web data and the specific URLs you provide.
+
+## Attributing Sources with inline Citations
+
+The API returns structured citation data, giving you complete control over how you display sources in your user interface. You can use the `groundingSupports` and `groundingChunks` fields to link the model's statements directly to their sources. Here is a common pattern for processing the metadata to create a response with inline, clickable citations.
+    
+    
+    def add_citations(response):
+        text = response.text
+        supports = response.candidates[0].grounding_metadata.grounding_supports
+        chunks = response.candidates[0].grounding_metadata.grounding_chunks
+    
+        # Sort supports by end_index in descending order to avoid shifting issues when inserting.
+        sorted_supports = sorted(supports, key=lambda s: s.segment.end_index, reverse=True)
+    
+        for support in sorted_supports:
+            end_index = support.segment.end_index
+            if support.grounding_chunk_indices:
+                # Create citation string like [1](link1)[2](link2)
+                citation_links = []
+                for i in support.grounding_chunk_indices:
+                    if i < len(chunks):
+                        uri = chunks[i].web.uri
+                        citation_links.append(f"[{i + 1}]({uri})")
+    
+                citation_string = ", ".join(citation_links)
+                text = text[:end_index] + citation_string + text[end_index:]
+    
+        return text
+    
+    # Assuming response with grounding metadata
+    text_with_citations = add_citations(response)
+    print(text_with_citations)
+    
+    
+    
+    Spain won Euro 2024, defeating England 2-1 in the final.[1](https:/...), [2](https:/...), [4](https:/...), [5](https:/...) This victory marks Spain's record-breaking fourth European Championship title.[5]((https:/...), [2](https:/...), [3](https:/...), [4](https:/...)
+    
+
+## Pricing
+
+When you use Grounding with Google Search, your project is billed per API request that includes the `google_search` tool. If the model decides to execute multiple search queries to answer a single prompt (for example, searching for `"UEFA Euro 2024 winner"` and `"Spain vs England Euro 2024 final score"` within the same API call), this counts as a single billable use of the tool for that request.
+
+For detailed pricing information, see the [Gemini API pricing page](https://ai.google.dev/gemini-api/docs/pricing).
+
+## Supported Models
+
+Experimental and Preview models are not included. You can find their capabilities on the [model overview](https://ai.google.dev/gemini-api/docs/models) page.
+
+Model | Grounding with Google Search  
+---|---  
+Gemini 2.5 Pro | ✔️  
+Gemini 2.5 Flash | ✔️  
+Gemini 2.0 Flash | ✔️  
+Gemini 1.5 Pro | ✔️  
+Gemini 1.5 Flash | ✔️  
+**Note:** Older models use a `google_search_retrieval` tool. For all current models, use the `google_search` tool as shown in the examples.
+
+## Grounding with Gemini 1.5 Models (Legacy)
+
+While the `google_search` tool is recommended for Gemini 2.0 and later, Gemini 1.5 support a legacy tool named `google_search_retrieval`. This tool provides a `dynamic` mode that allows the model to decide whether to perform a search based on its confidence that the prompt requires fresh information. If the model's confidence is above a `dynamic_threshold` you set (a value between 0.0 and 1.0), it will perform a search. 
+    
+    
+    # Note: This is a legacy approach for Gemini 1.5 models.
+    # The 'google_search' tool is recommended for all new development.
+    import os
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    retrieval_tool = types.Tool(
+        google_search_retrieval=types.GoogleSearchRetrieval(
+            dynamic_retrieval_config=types.DynamicRetrievalConfig(
+                mode=types.DynamicRetrievalConfigMode.MODE_DYNAMIC,
+                dynamic_threshold=0.7 # Only search if confidence > 70%
+            )
+        )
+    )
+    
+    config = types.GenerateContentConfig(
+        tools=[retrieval_tool]
+    )
+    
+    response = client.models.generate_content(
+        model='gemini-1.5-flash',
+        contents="Who won the euro 2024?",
+        config=config,
+    )
+    print(response.text)
+    if not response.candidates[0].grounding_metadata:
+      print("\nModel answered from its own knowledge.")
+    
+
+## What's next
+
+  * Try the [Grounding with Google Search in the Gemini API Cookbook](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Search_Grounding.ipynb).
+  * Learn about other available tools, like [Function Calling](/gemini-api/docs/function-calling).
+  * Learn how to augment prompts with specific URLs using the [URL context tool](/gemini-api/docs/url-context).
+
+

documentation_gemini/image_generation_with_gemini.md

@@ -0,0 +1,137 @@
+# Image generation with Gemini
+
+Source: <https://ai.google.dev/gemini-api/docs/image-generation>
+
+---
+
+Gemini can generate and process images conversationally. You can prompt Gemini with text, images, or a combination of both to achieve various image-related tasks, such as image generation and editing. All generated images include a [SynthID watermark](/responsible/docs/safeguards/synthid).
+
+Image generation may not be available in all regions and countries, review our [Gemini models](/gemini-api/docs/models#gemini-2.0-flash-preview-image-generation) page for more information.
+
+**Note:** You can also generate images with [Imagen](/gemini-api/docs/imagen), our specialized image generation model. See the When to use Imagen section for details on how to choose between Gemini and Imagen.
+
+## Image generation (text-to-image)
+
+The following code demonstrates how to generate an image based on a descriptive prompt. You must include `responseModalities`: `["TEXT", "IMAGE"]` in your configuration. Image-only output is not supported with these models.
+    
+    
+    from google import genai
+    from google.genai import types
+    from PIL import Image
+    from io import BytesIO
+    import base64
+    
+    client = genai.Client()
+    
+    contents = ('Hi, can you create a 3d rendered image of a pig '
+                'with wings and a top hat flying over a happy '
+                'futuristic scifi city with lots of greenery?')
+    
+    response = client.models.generate_content(
+        model="gemini-2.0-flash-preview-image-generation",
+        contents=contents,
+        config=types.GenerateContentConfig(
+          response_modalities=['TEXT', 'IMAGE']
+        )
+    )
+    
+    for part in response.candidates[0].content.parts:
+      if part.text is not None:
+        print(part.text)
+      elif part.inline_data is not None:
+        image = Image.open(BytesIO((part.inline_data.data)))
+        image.save('gemini-native-image.png')
+        image.show()
+    
+
+![AI-generated image of a fantastical flying pig](/static/gemini-api/docs/images/flying-pig.png) AI-generated image of a fantastical flying pig
+
+## Image editing (text-and-image-to-image)
+
+To perform image editing, add an image as input. The following example demonstrates uploading base64 encoded images. For multiple images and larger payloads, check the [image input](/gemini-api/docs/image-understanding#image-input) section.
+    
+    
+    from google import genai
+    from google.genai import types
+    from PIL import Image
+    from io import BytesIO
+    
+    import PIL.Image
+    
+    image = PIL.Image.open('/path/to/image.png')
+    
+    client = genai.Client()
+    
+    text_input = ('Hi, This is a picture of me.'
+                'Can you add a llama next to me?',)
+    
+    response = client.models.generate_content(
+        model="gemini-2.0-flash-preview-image-generation",
+        contents=[text_input, image],
+        config=types.GenerateContentConfig(
+          response_modalities=['TEXT', 'IMAGE']
+        )
+    )
+    
+    for part in response.candidates[0].content.parts:
+      if part.text is not None:
+        print(part.text)
+      elif part.inline_data is not None:
+        image = Image.open(BytesIO((part.inline_data.data)))
+        image.show()
+    
+
+## Other image generation modes
+
+Gemini supports other image interaction modes based on prompt structure and context, including:
+
+  * **Text to image(s) and text (interleaved):** Outputs images with related text. 
+    * Example prompt: "Generate an illustrated recipe for a paella."
+  * **Image(s) and text to image(s) and text (interleaved)** : Uses input images and text to create new related images and text. 
+    * Example prompt: (With an image of a furnished room) "What other color sofas would work in my space? can you update the image?"
+  * **Multi-turn image editing (chat):** Keep generating / editing images conversationally. 
+    * Example prompts: [upload an image of a blue car.] , "Turn this car into a convertible.", "Now change the color to yellow."
+
+
+
+## Limitations
+
+  * For best performance, use the following languages: EN, es-MX, ja-JP, zh-CN, hi-IN.
+  * Image generation does not support audio or video inputs.
+  * Image generation may not always trigger: 
+    * The model may output text only. Try asking for image outputs explicitly (e.g. "generate an image", "provide images as you go along", "update the image").
+    * The model may stop generating partway through. Try again or try a different prompt.
+  * When generating text for an image, Gemini works best if you first generate the text and then ask for an image with the text.
+  * There are some regions/countries where Image generation is not available. See [Models](/gemini-api/docs/models) for more information.
+
+
+
+## When to use Imagen
+
+In addition to using Gemini's built-in image generation capabilities, you can also access [Imagen](/gemini-api/docs/imagen), our specialized image generation model, through the Gemini API.
+
+Choose **Gemini** when:
+
+  * You need contextually relevant images that leverage world knowledge and reasoning.
+  * Seamlessly blending text and images is important.
+  * You want accurate visuals embedded within long text sequences.
+  * You want to edit images conversationally while maintaining context.
+
+
+
+Choose **Imagen** when:
+
+  * Image quality, photorealism, artistic detail, or specific styles (e.g., impressionism, anime) are top priorities.
+  * Performing specialized editing tasks like product background updates or image upscaling.
+  * Infusing branding, style, or generating logos and product designs.
+
+
+
+Imagen 4 should be your go-to model starting to generate images with Imagen. Choose Imagen 4 Ultra for advanced use-cases or when you need the best image quality. Note that Imagen 4 Ultra can only generate one image at a time.
+
+## What's next
+
+  * Check out the [Veo guide](/gemini-api/docs/video) to learn how to generate videos with the Gemini API.
+  * To learn more about Gemini models, see [Gemini models](/gemini-api/docs/models/gemini) and [Experimental models](/gemini-api/docs/models/experimental-models).
+
+

documentation_gemini/image_understanding.md

@@ -0,0 +1,352 @@
+# Image understanding
+
+Source: <https://ai.google.dev/gemini-api/docs/image-understanding>
+
+---
+
+Gemini models are built to be multimodal from the ground up, unlocking a wide range of image processing and computer vision tasks including but not limited to image captioning, classification, and visual question answering without having to train specialized ML models.
+
+**Tip:** In addition to their general multimodal capabilities, Gemini models (2.0 and newer) offer **improved accuracy** for specific use cases like object detection and segmentation, through additional training. See the Capabilities section for more details.
+
+## Passing images to Gemini
+
+You can provide images as input to Gemini using two methods:
+
+  * Passing inline image data: Ideal for smaller files (total request size less than 20MB, including prompts).
+  * Uploading images using the File API: Recommended for larger files or for reusing images across multiple requests.
+
+
+
+### Passing inline image data
+
+You can pass inline image data in the request to `generateContent`. You can provide image data as Base64 encoded strings or by reading local files directly (depending on the language).
+
+The following example shows how to read an image from a local file and pass it to `generateContent` API for processing.
+    
+    
+      from google.genai import types
+    
+      with open('path/to/small-sample.jpg', 'rb') as f:
+          image_bytes = f.read()
+    
+      response = client.models.generate_content(
+        model='gemini-2.5-flash',
+        contents=[
+          types.Part.from_bytes(
+            data=image_bytes,
+            mime_type='image/jpeg',
+          ),
+          'Caption this image.'
+        ]
+      )
+    
+      print(response.text)
+    
+
+You can also fetch an image from a URL, convert it to bytes, and pass it to `generateContent` as shown in the following examples.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    import requests
+    
+    image_path = "https://goo.gle/instrument-img"
+    image_bytes = requests.get(image_path).content
+    image = types.Part.from_bytes(
+      data=image_bytes, mime_type="image/jpeg"
+    )
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=["What is this image?", image],
+    )
+    
+    print(response.text)
+    
+
+**Note:** Inline image data limits your total request size (text prompts, system instructions, and inline bytes) to 20MB. For larger requests, upload image files using the File API. Files API is also more efficient for scenarios that use the same image repeatedly.
+
+### Uploading images using the File API
+
+For large files or to be able to use the same image file repeatedly, use the Files API. The following code uploads an image file and then uses the file in a call to `generateContent`. See the [Files API guide](/gemini-api/docs/files) for more information and examples.
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    
+    my_file = client.files.upload(file="path/to/sample.jpg")
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=[my_file, "Caption this image."],
+    )
+    
+    print(response.text)
+    
+
+## Prompting with multiple images
+
+You can provide multiple images in a single prompt by including multiple image `Part` objects in the `contents` array. These can be a mix of inline data (local files or URLs) and File API references.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    # Upload the first image
+    image1_path = "path/to/image1.jpg"
+    uploaded_file = client.files.upload(file=image1_path)
+    
+    # Prepare the second image as inline data
+    image2_path = "path/to/image2.png"
+    with open(image2_path, 'rb') as f:
+        img2_bytes = f.read()
+    
+    # Create the prompt with text and multiple images
+    response = client.models.generate_content(
+    
+        model="gemini-2.5-flash",
+        contents=[
+            "What is different between these two images?",
+            uploaded_file,  # Use the uploaded file reference
+            types.Part.from_bytes(
+                data=img2_bytes,
+                mime_type='image/png'
+            )
+        ]
+    )
+    
+    print(response.text)
+    
+
+## Object detection
+
+From Gemini 2.0 onwards, models are further trained to detect objects in an image and get their bounding box coordinates. The coordinates, relative to image dimensions, scale to [0, 1000]. You need to descale these coordinates based on your original image size.
+    
+    
+    from google import genai
+    from google.genai import types
+    from PIL import Image
+    import json
+    
+    client = genai.Client()
+    prompt = "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."
+    
+    image = Image.open("/path/to/image.png")
+    
+    config = types.GenerateContentConfig(
+      response_mime_type="application/json"
+      )
+    
+    response = client.models.generate_content(model="gemini-2.5-flash",
+                                              contents=[image, prompt],
+                                              config=config
+                                              )
+    
+    width, height = image.size
+    bounding_boxes = json.loads(response.text)
+    
+    converted_bounding_boxes = []
+    for bounding_box in bounding_boxes:
+        abs_y1 = int(bounding_box["box_2d"][0]/1000 * height)
+        abs_x1 = int(bounding_box["box_2d"][1]/1000 * width)
+        abs_y2 = int(bounding_box["box_2d"][2]/1000 * height)
+        abs_x2 = int(bounding_box["box_2d"][3]/1000 * width)
+        converted_bounding_boxes.append([abs_x1, abs_y1, abs_x2, abs_y2])
+    
+    print("Image size: ", width, height)
+    print("Bounding boxes:", converted_bounding_boxes)
+    
+    
+
+**Note:** The model also supports generating bounding boxes based on custom instructions, such as: "Show bounding boxes of all green objects in this image". It also support custom labels like "label the items with the allergens they can contain".
+
+For more examples, check following notebooks in the [Gemini Cookbook](https://github.com/google-gemini/cookbook):
+
+  * [2D spatial understanding notebook](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Spatial_understanding.ipynb)
+  * [Experimental 3D pointing notebook](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/examples/Spatial_understanding_3d.ipynb)
+
+
+
+## Segmentation
+
+Starting with Gemini 2.5, models not only detect items but also segment them and provide their contour masks.
+
+The model predicts a JSON list, where each item represents a segmentation mask. Each item has a bounding box ("`box_2d`") in the format `[y0, x0, y1, x1]` with normalized coordinates between 0 and 1000, a label ("`label`") that identifies the object, and finally the segmentation mask inside the bounding box, as base64 encoded png that is a probability map with values between 0 and 255. The mask needs to be resized to match the bounding box dimensions, then binarized at your confidence threshold (127 for the midpoint).
+
+**Note:** For better results, disable [thinking](/gemini-api/docs/thinking) by setting the thinking budget to 0. See code sample below for an example.
+    
+    
+    from google import genai
+    from google.genai import types
+    from PIL import Image, ImageDraw
+    import io
+    import base64
+    import json
+    import numpy as np
+    import os
+    
+    client = genai.Client()
+    
+    def parse_json(json_output: str):
+      # Parsing out the markdown fencing
+      lines = json_output.splitlines()
+      for i, line in enumerate(lines):
+        if line == "```json":
+          json_output = "\n".join(lines[i+1:])  # Remove everything before "```json"
+          output = json_output.split("```")[0]  # Remove everything after the closing "```"
+          break  # Exit the loop once "```json" is found
+      return json_output
+    
+    def extract_segmentation_masks(image_path: str, output_dir: str = "segmentation_outputs"):
+      # Load and resize image
+      im = Image.open(image_path)
+      im.thumbnail([1024, 1024], Image.Resampling.LANCZOS)
+    
+      prompt = """
+      Give the segmentation masks for the wooden and glass items.
+      Output a JSON list of segmentation masks where each entry contains the 2D
+      bounding box in the key "box_2d", the segmentation mask in key "mask", and
+      the text label in the key "label". Use descriptive labels.
+      """
+    
+      config = types.GenerateContentConfig(
+        thinking_config=types.ThinkingConfig(thinking_budget=0) # set thinking_budget to 0 for better results in object detection
+      )
+    
+      response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=[prompt, im], # Pillow images can be directly passed as inputs (which will be converted by the SDK)
+        config=config
+      )
+    
+      # Parse JSON response
+      items = json.loads(parse_json(response.text))
+    
+      # Create output directory
+      os.makedirs(output_dir, exist_ok=True)
+    
+      # Process each mask
+      for i, item in enumerate(items):
+          # Get bounding box coordinates
+          box = item["box_2d"]
+          y0 = int(box[0] / 1000 * im.size[1])
+          x0 = int(box[1] / 1000 * im.size[0])
+          y1 = int(box[2] / 1000 * im.size[1])
+          x1 = int(box[3] / 1000 * im.size[0])
+    
+          # Skip invalid boxes
+          if y0 >= y1 or x0 >= x1:
+              continue
+    
+          # Process mask
+          png_str = item["mask"]
+          if not png_str.startswith("data:image/png;base64,"):
+              continue
+    
+          # Remove prefix
+          png_str = png_str.removeprefix("data:image/png;base64,")
+          mask_data = base64.b64decode(png_str)
+          mask = Image.open(io.BytesIO(mask_data))
+    
+          # Resize mask to match bounding box
+          mask = mask.resize((x1 - x0, y1 - y0), Image.Resampling.BILINEAR)
+    
+          # Convert mask to numpy array for processing
+          mask_array = np.array(mask)
+    
+          # Create overlay for this mask
+          overlay = Image.new('RGBA', im.size, (0, 0, 0, 0))
+          overlay_draw = ImageDraw.Draw(overlay)
+    
+          # Create overlay for the mask
+          color = (255, 255, 255, 200)
+          for y in range(y0, y1):
+              for x in range(x0, x1):
+                  if mask_array[y - y0, x - x0] > 128:  # Threshold for mask
+                      overlay_draw.point((x, y), fill=color)
+    
+          # Save individual mask and its overlay
+          mask_filename = f"{item['label']}_{i}_mask.png"
+          overlay_filename = f"{item['label']}_{i}_overlay.png"
+    
+          mask.save(os.path.join(output_dir, mask_filename))
+    
+          # Create and save overlay
+          composite = Image.alpha_composite(im.convert('RGBA'), overlay)
+          composite.save(os.path.join(output_dir, overlay_filename))
+          print(f"Saved mask and overlay for {item['label']} to {output_dir}")
+    
+    # Example usage
+    if __name__ == "__main__":
+      extract_segmentation_masks("path/to/image.png")
+    
+    
+
+Check the [segmentation example](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Spatial_understanding.ipynb#scrollTo=WQJTJ8wdGOKx) in the cookbook guide for a more detailed example.
+
+![A table with cupcakes, with the wooden and glass objects highlighted](/static/gemini-api/docs/images/segmentation.jpg) An example segmentation output with objects and segmentation masks
+
+## Supported image formats
+
+Gemini supports the following image format MIME types:
+
+  * PNG - `image/png`
+  * JPEG - `image/jpeg`
+  * WEBP - `image/webp`
+  * HEIC - `image/heic`
+  * HEIF - `image/heif`
+
+
+
+## Capabilities
+
+All Gemini model versions are multimodal and can be utilized in a wide range of image processing and computer vision tasks including but not limited to image captioning, visual question and answering, image classification, object detection and segmentation.
+
+Gemini can reduce the need to use specialized ML models depending on your quality and performance requirements.
+
+Some later model versions are specifically trained improve accuracy of specialized tasks in addition to generic capabilities:
+
+  * **Gemini 2.0 models** are further trained to support enhanced object detection.
+
+  * **Gemini 2.5 models** are further trained to support enhanced segmentation in addition to object detection.
+
+
+
+
+## Limitations and key technical information
+
+### File limit
+
+Gemini 2.5 Pro/Flash, 2.0 Flash, 1.5 Pro, and 1.5 Flash support a maximum of 3,600 image files per request.
+
+### Token calculation
+
+  * **Gemini 1.5 Flash and Gemini 1.5 Pro** : 258 tokens if both dimensions <= 384 pixels. Larger images are tiled (min tile 256px, max 768px, resized to 768x768), with each tile costing 258 tokens.
+  * **Gemini 2.0 Flash and Gemini 2.5 Flash/Pro** : 258 tokens if both dimensions <= 384 pixels. Larger images are tiled into 768x768 pixel tiles, each costing 258 tokens.
+
+
+
+## Tips and best practices
+
+  * Verify that images are correctly rotated.
+  * Use clear, non-blurry images.
+  * When using a single image with text, place the text prompt _after_ the image part in the `contents` array.
+
+
+
+## What's next
+
+This guide shows you how to upload image files and generate text outputs from image inputs. To learn more, see the following resources:
+
+  * [Files API](/gemini-api/docs/files): Learn more about uploading and managing files for use with Gemini.
+  * [System instructions](/gemini-api/docs/text-generation#system-instructions): System instructions let you steer the behavior of the model based on your specific needs and use cases.
+  * [File prompting strategies](/gemini-api/docs/files#prompt-guide): The Gemini API supports prompting with text, image, audio, and video data, also known as multimodal prompting.
+  * [Safety guidance](/gemini-api/docs/safety-guidance): Sometimes generative AI models produce unexpected outputs, such as outputs that are inaccurate, biased, or offensive. Post-processing and human evaluation are essential to limit the risk of harm from such outputs.
+
+

documentation_gemini/long_context.md

@@ -0,0 +1,116 @@
+# Long context
+
+Source: <https://ai.google.dev/gemini-api/docs/long-context>
+
+---
+
+Many Gemini models come with large context windows of 1 million or more tokens. Historically, large language models (LLMs) were significantly limited by the amount of text (or tokens) that could be passed to the model at one time. The Gemini long context window unlocks many new use cases and developer paradigms.
+
+The code you already use for cases like [text generation](/gemini-api/docs/text-generation) or [multimodal inputs](/gemini-api/docs/vision) will work without any changes with long context.
+
+This document gives you an overview of what you can achieve using models with context windows of 1M and more tokens. The page gives a brief overview of a context window, and explores how developers should think about long context, various real world use cases for long context, and ways to optimize the usage of long context.
+
+For the context window sizes of specific models, see the [Models](/gemini-api/docs/models) page.
+
+## What is a context window?
+
+The basic way you use the Gemini models is by passing information (context) to the model, which will subsequently generate a response. An analogy for the context window is short term memory. There is a limited amount of information that can be stored in someone's short term memory, and the same is true for generative models.
+
+You can read more about how models work under the hood in our [generative models guide](/gemini-api/docs/prompting-strategies#under-the-hood).
+
+## Getting started with long context
+
+Earlier versions of generative models were only able to process 8,000 tokens at a time. Newer models pushed this further by accepting 32,000 or even 128,000 tokens. Gemini is the first model capable of accepting 1 million tokens.
+
+In practice, 1 million tokens would look like:
+
+  * 50,000 lines of code (with the standard 80 characters per line)
+  * All the text messages you have sent in the last 5 years
+  * 8 average length English novels
+  * Transcripts of over 200 average length podcast episodes
+
+
+
+The more limited context windows common in many other models often require strategies like arbitrarily dropping old messages, summarizing content, using RAG with vector databases, or filtering prompts to save tokens.
+
+While these techniques remain valuable in specific scenarios, Gemini's extensive context window invites a more direct approach: providing all relevant information upfront. Because Gemini models were purpose-built with massive context capabilities, they demonstrate powerful in-context learning. For example, using only in-context instructional materials (a 500-page reference grammar, a dictionary, and ≈400 parallel sentences), Gemini [learned to translate](https://storage.googleapis.com/deepmind-media/gemini/gemini_v1_5_report.pdf) from English to Kalamang—a Papuan language with fewer than 200 speakers—with quality similar to a human learner using the same materials. This illustrates the paradigm shift enabled by Gemini's long context, empowering new possibilities through robust in-context learning.
+
+## Long context use cases
+
+While the standard use case for most generative models is still text input, the Gemini model family enables a new paradigm of multimodal use cases. These models can natively understand text, video, audio, and images. They are accompanied by the [Gemini API that takes in multimodal file types](/gemini-api/docs/prompting_with_media) for convenience.
+
+### Long form text
+
+Text has proved to be the layer of intelligence underpinning much of the momentum around LLMs. As mentioned earlier, much of the practical limitation of LLMs was because of not having a large enough context window to do certain tasks. This led to the rapid adoption of retrieval augmented generation (RAG) and other techniques which dynamically provide the model with relevant contextual information. Now, with larger and larger context windows, there are new techniques becoming available which unlock new use cases.
+
+Some emerging and standard use cases for text based long context include:
+
+  * Summarizing large corpuses of text 
+    * Previous summarization options with smaller context models would require a sliding window or another technique to keep state of previous sections as new tokens are passed to the model
+  * Question and answering 
+    * Historically this was only possible with RAG given the limited amount of context and models' factual recall being low
+  * Agentic workflows 
+    * Text is the underpinning of how agents keep state of what they have done and what they need to do; not having enough information about the world and the agent's goal is a limitation on the reliability of agents
+
+
+
+[Many-shot in-context learning](https://arxiv.org/pdf/2404.11018) is one of the most unique capabilities unlocked by long context models. Research has shown that taking the common "single shot" or "multi-shot" example paradigm, where the model is presented with one or a few examples of a task, and scaling that up to hundreds, thousands, or even hundreds of thousands of examples, can lead to novel model capabilities. This many-shot approach has also been shown to perform similarly to models which were fine-tuned for a specific task. For use cases where a Gemini model's performance is not yet sufficient for a production rollout, you can try the many-shot approach. As you might explore later in the long context optimization section, context caching makes this type of high input token workload much more economically feasible and even lower latency in some cases.
+
+### Long form video
+
+Video content's utility has long been constrained by the lack of accessibility of the medium itself. It was hard to skim the content, transcripts often failed to capture the nuance of a video, and most tools don't process image, text, and audio together. With Gemini, the long-context text capabilities translate to the ability to reason and answer questions about multimodal inputs with sustained performance.
+
+Some emerging and standard use cases for video long context include:
+
+  * Video question and answering
+  * Video memory, as shown with [Google's Project Astra](https://deepmind.google/technologies/gemini/project-astra/)
+  * Video captioning
+  * Video recommendation systems, by enriching existing metadata with new multimodal understanding
+  * Video customization, by looking at a corpus of data and associated video metadata and then removing parts of videos that are not relevant to the viewer
+  * Video content moderation
+  * Real-time video processing
+
+
+
+When working with videos, it is important to consider how the [videos are processed into tokens](/gemini-api/docs/tokens#media-token), which affects billing and usage limits. You can learn more about prompting with video files in the [Prompting guide](/gemini-api/docs/prompting_with_media?lang=python#prompting-with-videos).
+
+### Long form audio
+
+The Gemini models were the first natively multimodal large language models that could understand audio. Historically, the typical developer workflow would involve stringing together multiple domain specific models, like a speech-to-text model and a text-to-text model, in order to process audio. This led to additional latency required by performing multiple round-trip requests and decreased performance usually attributed to disconnected architectures of the multiple model setup.
+
+Some emerging and standard use cases for audio context include:
+
+  * Real-time transcription and translation
+  * Podcast / video question and answering
+  * Meeting transcription and summarization
+  * Voice assistants
+
+
+
+You can learn more about prompting with audio files in the [Prompting guide](/gemini-api/docs/prompting_with_media?lang=python#prompting-with-videos).
+
+## Long context optimizations
+
+The primary optimization when working with long context and the Gemini models is to use [context caching](/gemini-api/docs/caching). Beyond the previous impossibility of processing lots of tokens in a single request, the other main constraint was the cost. If you have a "chat with your data" app where a user uploads 10 PDFs, a video, and some work documents, you would historically have to work with a more complex retrieval augmented generation (RAG) tool / framework in order to process these requests and pay a significant amount for tokens moved into the context window. Now, you can cache the files the user uploads and pay to store them on a per hour basis. The input / output cost per request with Gemini Flash for example is ~4x less than the standard input / output cost, so if the user chats with their data enough, it becomes a huge cost saving for you as the developer.
+
+## Long context limitations
+
+In various sections of this guide, we talked about how Gemini models achieve high performance across various needle-in-a-haystack retrieval evals. These tests consider the most basic setup, where you have a single needle you are looking for. In cases where you might have multiple "needles" or specific pieces of information you are looking for, the model does not perform with the same accuracy. Performance can vary to a wide degree depending on the context. This is important to consider as there is an inherent tradeoff between getting the right information retrieved and cost. You can get ~99% on a single query, but you have to pay the input token cost every time you send that query. So for 100 pieces of information to be retrieved, if you needed 99% performance, you would likely need to send 100 requests. This is a good example of where context caching can significantly reduce the cost associated with using Gemini models while keeping the performance high.
+
+## FAQs
+
+### Where is the best place to put my query in the context window?
+
+In most cases, especially if the total context is long, the model's performance will be better if you put your query / question at the end of the prompt (after all the other context).
+
+### Do I lose model performance when I add more tokens to a query?
+
+Generally, if you don't need tokens to be passed to the model, it is best to avoid passing them. However, if you have a large chunk of tokens with some information and want to ask questions about that information, the model is highly capable of extracting that information (up to 99% accuracy in many cases).
+
+### How can I lower my cost with long-context queries?
+
+If you have a similar set of tokens / context that you want to re-use many times, [context caching](/gemini-api/docs/caching) can help reduce the costs associated with asking questions about that information.
+
+### Does the context length affect the model latency?
+
+There is some fixed amount of latency in any given request, regardless of the size, but generally longer queries will have higher latency (time to first token).

documentation_gemini/speech_generation_text-to-speech.md

@@ -0,0 +1,256 @@
+# Speech generation (text-to-speech)
+
+Source: <https://ai.google.dev/gemini-api/docs/speech-generation>
+
+---
+
+The Gemini API can transform text input into single speaker or multi-speaker audio using native text-to-speech (TTS) generation capabilities. Text-to-speech (TTS) generation is _controllable_ , meaning you can use natural language to structure interactions and guide the _style_ , _accent_ , _pace_ , and _tone_ of the audio.
+
+The TTS capability differs from speech generation provided through the [Live API](/gemini-api/docs/live), which is designed for interactive, unstructured audio, and multimodal inputs and outputs. While the Live API excels in dynamic conversational contexts, TTS through the Gemini API is tailored for scenarios that require exact text recitation with fine-grained control over style and sound, such as podcast or audiobook generation.
+
+This guide shows you how to generate single-speaker and multi-speaker audio from text.
+
+**Preview:** Native text-to-speech (TTS) is in [Preview](/gemini-api/docs/models#preview).
+
+## Before you begin
+
+Ensure you use a Gemini 2.5 model variant with native text-to-speech (TTS) capabilities, as listed in the [Supported models](/gemini-api/docs/speech-generation#supported-models) section. For optimal results, consider which model best fits your specific use case. 
+
+You may find it useful to [test the Gemini 2.5 TTS models in AI Studio](https://aistudio.google.com/generate-speech) before you start building.
+
+**Note:** TTS models accept text-only inputs and produce audio-only outputs. For a complete list of restrictions specific to TTS models, review the [Limitations](/gemini-api/docs/speech-generation#limitations) section.
+
+## Single-speaker text-to-speech
+
+To convert text to single-speaker audio, set the response modality to "audio", and pass a `SpeechConfig` object with `VoiceConfig` set. You'll need to choose a voice name from the prebuilt output voices.
+
+This example saves the output audio from the model in a wave file:
+    
+    
+    from google import genai
+    from google.genai import types
+    import wave
+    
+    # Set up the wave file to save the output:
+    def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
+       with wave.open(filename, "wb") as wf:
+          wf.setnchannels(channels)
+          wf.setsampwidth(sample_width)
+          wf.setframerate(rate)
+          wf.writeframes(pcm)
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+       model="gemini-2.5-flash-preview-tts",
+       contents="Say cheerfully: Have a wonderful day!",
+       config=types.GenerateContentConfig(
+          response_modalities=["AUDIO"],
+          speech_config=types.SpeechConfig(
+             voice_config=types.VoiceConfig(
+                prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                   voice_name='Kore',
+                )
+             )
+          ),
+       )
+    )
+    
+    data = response.candidates[0].content.parts[0].inline_data.data
+    
+    file_name='out.wav'
+    wave_file(file_name, data) # Saves the file to current directory
+    
+
+For more code samples, refer to the "TTS - Get Started" file in the cookbooks repository: 
+
+[View on GitHub](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_TTS.ipynb)
+
+## Multi-speaker text-to-speech
+
+For multi-speaker audio, you'll need a `MultiSpeakerVoiceConfig` object with each speaker (up to 2) configured as a `SpeakerVoiceConfig`. You'll need to define each `speaker` with the same names used in the prompt:
+    
+    
+    from google import genai
+    from google.genai import types
+    import wave
+    
+    # Set up the wave file to save the output:
+    def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
+       with wave.open(filename, "wb") as wf:
+          wf.setnchannels(channels)
+          wf.setsampwidth(sample_width)
+          wf.setframerate(rate)
+          wf.writeframes(pcm)
+    
+    client = genai.Client()
+    
+    prompt = """TTS the following conversation between Joe and Jane:
+             Joe: How's it going today Jane?
+             Jane: Not too bad, how about you?"""
+    
+    response = client.models.generate_content(
+       model="gemini-2.5-flash-preview-tts",
+       contents=prompt,
+       config=types.GenerateContentConfig(
+          response_modalities=["AUDIO"],
+          speech_config=types.SpeechConfig(
+             multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
+                speaker_voice_configs=[
+                   types.SpeakerVoiceConfig(
+                      speaker='Joe',
+                      voice_config=types.VoiceConfig(
+                         prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                            voice_name='Kore',
+                         )
+                      )
+                   ),
+                   types.SpeakerVoiceConfig(
+                      speaker='Jane',
+                      voice_config=types.VoiceConfig(
+                         prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                            voice_name='Puck',
+                         )
+                      )
+                   ),
+                ]
+             )
+          )
+       )
+    )
+    
+    data = response.candidates[0].content.parts[0].inline_data.data
+    
+    file_name='out.wav'
+    wave_file(file_name, data) # Saves the file to current directory
+    
+
+## Controlling speech style with prompts
+
+You can control style, tone, accent, and pace using natural language prompts for both single- and multi-speaker TTS. For example, in a single-speaker prompt, you can say:
+    
+    
+    Say in an spooky whisper:
+    "By the pricking of my thumbs...
+    Something wicked this way comes"
+    
+
+In a multi-speaker prompt, provide the model with each speaker's name and corresponding transcript. You can also provide guidance for each speaker individually:
+    
+    
+    Make Speaker1 sound tired and bored, and Speaker2 sound excited and happy:
+    
+    Speaker1: So... what's on the agenda today?
+    Speaker2: You're never going to guess!
+    
+
+Try using a voice option that corresponds to the style or emotion you want to convey, to emphasize it even more. In the previous prompt, for example, _Enceladus_ 's breathiness might emphasize "tired" and "bored", while _Puck_ 's upbeat tone could complement "excited" and "happy".
+
+## Generating a prompt to convert to audio
+
+The TTS models only output audio, but you can use [other models](/gemini-api/docs/models) to generate a transcript first, then pass that transcript to the TTS model to read aloud.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    transcript = client.models.generate_content(
+       model="gemini-2.0-flash",
+       contents="""Generate a short transcript around 100 words that reads
+                like it was clipped from a podcast by excited herpetologists.
+                The hosts names are Dr. Anya and Liam.""").text
+    
+    response = client.models.generate_content(
+       model="gemini-2.5-flash-preview-tts",
+       contents=transcript,
+       config=types.GenerateContentConfig(
+          response_modalities=["AUDIO"],
+          speech_config=types.SpeechConfig(
+             multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
+                speaker_voice_configs=[
+                   types.SpeakerVoiceConfig(
+                      speaker='Dr. Anya',
+                      voice_config=types.VoiceConfig(
+                         prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                            voice_name='Kore',
+                         )
+                      )
+                   ),
+                   types.SpeakerVoiceConfig(
+                      speaker='Liam',
+                      voice_config=types.VoiceConfig(
+                         prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                            voice_name='Puck',
+                         )
+                      )
+                   ),
+                ]
+             )
+          )
+       )
+    )
+    
+    # ...Code to stream or save the output
+    
+
+## Voice options
+
+TTS models support the following 30 voice options in the `voice_name` field:
+
+**Zephyr** \-- _Bright_ | **Puck** \-- _Upbeat_ | **Charon** \-- _Informative_  
+---|---|---  
+**Kore** \-- _Firm_ | **Fenrir** \-- _Excitable_ | **Leda** \-- _Youthful_  
+**Orus** \-- _Firm_ | **Aoede** \-- _Breezy_ | **Callirrhoe** \-- _Easy-going_  
+**Autonoe** \-- _Bright_ | **Enceladus** \-- _Breathy_ | **Iapetus** \-- _Clear_  
+**Umbriel** \-- _Easy-going_ | **Algieba** \-- _Smooth_ | **Despina** \-- _Smooth_  
+**Erinome** \-- _Clear_ | **Algenib** \-- _Gravelly_ | **Rasalgethi** \-- _Informative_  
+**Laomedeia** \-- _Upbeat_ | **Achernar** \-- _Soft_ | **Alnilam** \-- _Firm_  
+**Schedar** \-- _Even_ | **Gacrux** \-- _Mature_ | **Pulcherrima** \-- _Forward_  
+**Achird** \-- _Friendly_ | **Zubenelgenubi** \-- _Casual_ | **Vindemiatrix** \-- _Gentle_  
+**Sadachbia** \-- _Lively_ | **Sadaltager** \-- _Knowledgeable_ | **Sulafat** \-- _Warm_  
+  
+You can hear all the voice options in [AI Studio](https://aistudio.google.com/generate-speech).
+
+## Supported languages
+
+The TTS models detect the input language automatically. They support the following 24 languages:
+
+Language | BCP-47 Code | Language | BCP-47 Code  
+---|---|---|---  
+Arabic (Egyptian) | `ar-EG` | German (Germany) | `de-DE`  
+English (US) | `en-US` | Spanish (US) | `es-US`  
+French (France) | `fr-FR` | Hindi (India) | `hi-IN`  
+Indonesian (Indonesia) | `id-ID` | Italian (Italy) | `it-IT`  
+Japanese (Japan) | `ja-JP` | Korean (Korea) | `ko-KR`  
+Portuguese (Brazil) | `pt-BR` | Russian (Russia) | `ru-RU`  
+Dutch (Netherlands) | `nl-NL` | Polish (Poland) | `pl-PL`  
+Thai (Thailand) | `th-TH` | Turkish (Turkey) | `tr-TR`  
+Vietnamese (Vietnam) | `vi-VN` | Romanian (Romania) | `ro-RO`  
+Ukrainian (Ukraine) | `uk-UA` | Bengali (Bangladesh) | `bn-BD`  
+English (India) | `en-IN` & `hi-IN` bundle | Marathi (India) | `mr-IN`  
+Tamil (India) | `ta-IN` | Telugu (India) | `te-IN`  
+  
+## Supported models
+
+Model | Single speaker | Multispeaker  
+---|---|---  
+[Gemini 2.5 Flash Preview TTS](/gemini-api/docs/models#gemini-2.5-flash-preview-tts) | ✔️ | ✔️  
+[Gemini 2.5 Pro Preview TTS](/gemini-api/docs/models#gemini-2.5-pro-preview-tts) | ✔️ | ✔️  
+  
+## Limitations
+
+  * TTS models can only receive text inputs and generate audio outputs. 
+  * A TTS session has a [context window](/gemini-api/docs/long-context) limit of 32k tokens.
+  * Review [Languages](/gemini-api/docs/speech-generation#languages) section for language support.
+
+
+
+## What's next
+
+  * Try the [audio generation cookbook](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_TTS.ipynb).
+  * Gemini's [Live API](/gemini-api/docs/live) offers interactive audio generation options you can interleave with other modalities.
+  * For working with audio _inputs_ , visit the [Audio understanding](/gemini-api/docs/audio) guide.
+
+

documentation_gemini/structured_output.md

@@ -0,0 +1,392 @@
+# Structured output
+
+Source: <https://ai.google.dev/gemini-api/docs/structured-output>
+
+---
+
+You can configure Gemini for structured output instead of unstructured text, allowing precise extraction and standardization of information for further processing. For example, you can use structured output to extract information from resumes, standardize them to build a structured database.
+
+Gemini can generate either [JSON](/gemini-api/docs/structured-output#generating-json) or [enum values](/gemini-api/docs/structured-output#generating-enums) as structured output.
+
+## Generating JSON
+
+To constrain the model to generate JSON, configure a `responseSchema`. The model will then respond to any prompt with JSON-formatted output.
+    
+    
+    from google import genai
+    from pydantic import BaseModel
+    
+    class Recipe(BaseModel):
+        recipe_name: str
+        ingredients: list[str]
+    
+    client = genai.Client()
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="List a few popular cookie recipes, and include the amounts of ingredients.",
+        config={
+            "response_mime_type": "application/json",
+            "response_schema": list[Recipe],
+        },
+    )
+    # Use the response as a JSON string.
+    print(response.text)
+    
+    # Use instantiated objects.
+    my_recipes: list[Recipe] = response.parsed
+    
+
+**Note:** [Pydantic validators](https://docs.pydantic.dev/latest/concepts/validators/) are not yet supported. If a `pydantic.ValidationError` occurs, it is suppressed, and `.parsed` may be empty/null.
+
+The output might look like this:
+    
+    
+    [
+      {
+        "recipeName": "Chocolate Chip Cookies",
+        "ingredients": [
+          "1 cup (2 sticks) unsalted butter, softened",
+          "3/4 cup granulated sugar",
+          "3/4 cup packed brown sugar",
+          "1 teaspoon vanilla extract",
+          "2 large eggs",
+          "2 1/4 cups all-purpose flour",
+          "1 teaspoon baking soda",
+          "1 teaspoon salt",
+          "2 cups chocolate chips"
+        ]
+      },
+      ...
+    ]
+    
+
+## Generating enum values
+
+In some cases you might want the model to choose a single option from a list of options. To implement this behavior, you can pass an _enum_ in your schema. You can use an enum option anywhere you could use a `string` in the `responseSchema`, because an enum is an array of strings. Like a JSON schema, an enum lets you constrain model output to meet the requirements of your application.
+
+For example, assume that you're developing an application to classify musical instruments into one of five categories: `"Percussion"`, `"String"`, `"Woodwind"`, `"Brass"`, or "`"Keyboard"`". You could create an enum to help with this task.
+
+In the following example, you pass an enum as the `responseSchema`, constraining the model to choose the most appropriate option.
+    
+    
+    from google import genai
+    import enum
+    
+    class Instrument(enum.Enum):
+      PERCUSSION = "Percussion"
+      STRING = "String"
+      WOODWIND = "Woodwind"
+      BRASS = "Brass"
+      KEYBOARD = "Keyboard"
+    
+    client = genai.Client()
+    response = client.models.generate_content(
+        model='gemini-2.5-flash',
+        contents='What type of instrument is an oboe?',
+        config={
+            'response_mime_type': 'text/x.enum',
+            'response_schema': Instrument,
+        },
+    )
+    
+    print(response.text)
+    # Woodwind
+    
+
+The Python library will translate the type declarations for the API. However, the API accepts a subset of the OpenAPI 3.0 schema ([Schema](https://ai.google.dev/api/caching#schema)).
+
+There are two other ways to specify an enumeration. You can use a [`Literal`](https://docs.pydantic.dev/1.10/usage/types/#literal-type): ```
+    
+    
+    Literal["Percussion", "String", "Woodwind", "Brass", "Keyboard"]
+    
+
+And you can also pass the schema as JSON:
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    response = client.models.generate_content(
+        model='gemini-2.5-flash',
+        contents='What type of instrument is an oboe?',
+        config={
+            'response_mime_type': 'text/x.enum',
+            'response_schema': {
+                "type": "STRING",
+                "enum": ["Percussion", "String", "Woodwind", "Brass", "Keyboard"],
+            },
+        },
+    )
+    
+    print(response.text)
+    # Woodwind
+    
+
+Beyond basic multiple choice problems, you can use an enum anywhere in a JSON schema. For example, you could ask the model for a list of recipe titles and use a `Grade` enum to give each title a popularity grade:
+    
+    
+    from google import genai
+    
+    import enum
+    from pydantic import BaseModel
+    
+    class Grade(enum.Enum):
+        A_PLUS = "a+"
+        A = "a"
+        B = "b"
+        C = "c"
+        D = "d"
+        F = "f"
+    
+    class Recipe(BaseModel):
+      recipe_name: str
+      rating: Grade
+    
+    client = genai.Client()
+    response = client.models.generate_content(
+        model='gemini-2.5-flash',
+        contents='List 10 home-baked cookie recipes and give them grades based on tastiness.',
+        config={
+            'response_mime_type': 'application/json',
+            'response_schema': list[Recipe],
+        },
+    )
+    
+    print(response.text)
+    
+
+The response might look like this:
+    
+    
+    [
+      {
+        "recipe_name": "Chocolate Chip Cookies",
+        "rating": "a+"
+      },
+      {
+        "recipe_name": "Peanut Butter Cookies",
+        "rating": "a"
+      },
+      {
+        "recipe_name": "Oatmeal Raisin Cookies",
+        "rating": "b"
+      },
+      ...
+    ]
+    
+
+## About JSON schemas
+
+Configuring the model for JSON output using `responseSchema` parameter relies on `Schema` object to define its structure. This object represents a select subset of the [OpenAPI 3.0 Schema object](https://spec.openapis.org/oas/v3.0.3#schema-object), and also adds a `propertyOrdering` field.
+
+**Tip:** On Python, when you use a Pydantic model, you don't need to directly work with `Schema` objects, as it gets automatically converted to the corresponding JSON schema. To learn more, see JSON schemas in Python.
+
+Here's a pseudo-JSON representation of all the `Schema` fields:
+    
+    
+    {
+      "type": enum (Type),
+      "format": string,
+      "description": string,
+      "nullable": boolean,
+      "enum": [
+        string
+      ],
+      "maxItems": integer,
+      "minItems": integer,
+      "properties": {
+        string: {
+          object (Schema)
+        },
+        ...
+      },
+      "required": [
+        string
+      ],
+      "propertyOrdering": [
+        string
+      ],
+      "items": {
+        object (Schema)
+      }
+    }
+    
+
+The `Type` of the schema must be one of the OpenAPI [Data Types](https://spec.openapis.org/oas/v3.0.3#data-types), or a union of those types (using `anyOf`). Only a subset of fields is valid for each `Type`. The following list maps each `Type` to a subset of the fields that are valid for that type:
+
+  * `string` -> `enum`, `format`, `nullable`
+  * `integer` -> `format`, `minimum`, `maximum`, `enum`, `nullable`
+  * `number` -> `format`, `minimum`, `maximum`, `enum`, `nullable`
+  * `boolean` -> `nullable`
+  * `array` -> `minItems`, `maxItems`, `items`, `nullable`
+  * `object` -> `properties`, `required`, `propertyOrdering`, `nullable`
+
+
+
+Here are some example schemas showing valid type-and-field combinations:
+    
+    
+    { "type": "string", "enum": ["a", "b", "c"] }
+    
+    { "type": "string", "format": "date-time" }
+    
+    { "type": "integer", "format": "int64" }
+    
+    { "type": "number", "format": "double" }
+    
+    { "type": "boolean" }
+    
+    { "type": "array", "minItems": 3, "maxItems": 3, "items": { "type": ... } }
+    
+    { "type": "object",
+      "properties": {
+        "a": { "type": ... },
+        "b": { "type": ... },
+        "c": { "type": ... }
+      },
+      "nullable": true,
+      "required": ["c"],
+      "propertyOrdering": ["c", "b", "a"]
+    }
+    
+
+For complete documentation of the Schema fields as they're used in the Gemini API, see the [Schema reference](/api/caching#Schema).
+
+### Property ordering
+
+**Warning:** When you're configuring a JSON schema, make sure to set `propertyOrdering[]`, and when you provide examples, make sure that the property ordering in the examples matches the schema.
+
+When you're working with JSON schemas in the Gemini API, the order of properties is important. By default, the API orders properties alphabetically and does not preserve the order in which the properties are defined (although the [Google Gen AI SDKs](/gemini-api/docs/sdks) may preserve this order). If you're providing examples to the model with a schema configured, and the property ordering of the examples is not consistent with the property ordering of the schema, the output could be rambling or unexpected.
+
+To ensure a consistent, predictable ordering of properties, you can use the optional `propertyOrdering[]` field.
+    
+    
+    "propertyOrdering": ["recipeName", "ingredients"]
+    
+
+`propertyOrdering[]` – not a standard field in the OpenAPI specification – is an array of strings used to determine the order of properties in the response. By specifying the order of properties and then providing examples with properties in that same order, you can potentially improve the quality of results. `propertyOrdering` is only supported when you manually create `types.Schema`.
+
+### Schemas in Python
+
+When you're using the Python library, the value of `response_schema` must be one of the following:
+
+  * A type, as you would use in a type annotation (see the Python [`typing` module](https://docs.python.org/3/library/typing.html))
+  * An instance of [`genai.types.Schema`](https://googleapis.github.io/python-genai/genai.html#genai.types.Schema)
+  * The `dict` equivalent of `genai.types.Schema`
+
+
+
+The easiest way to define a schema is with a Pydantic type (as shown in the previous example):
+    
+    
+    config={'response_mime_type': 'application/json',
+            'response_schema': list[Recipe]}
+    
+
+When you use a Pydantic type, the Python library builds out a JSON schema for you and sends it to the API. For additional examples, see the [Python library docs](https://googleapis.github.io/python-genai/index.html#json-response-schema).
+
+The Python library supports schemas defined with the following types (where `AllowedType` is any allowed type):
+
+  * `int`
+  * `float`
+  * `bool`
+  * `str`
+  * `list[AllowedType]`
+  * `AllowedType|AllowedType|...`
+  * For structured types: 
+    * `dict[str, AllowedType]`. This annotation declares all dict values to be the same type, but doesn't specify what keys should be included.
+    * User-defined [Pydantic models](https://docs.pydantic.dev/latest/concepts/models/). This approach lets you specify the key names and define different types for the values associated with each of the keys, including nested structures.
+
+
+
+### JSON Schema support
+
+[JSON Schema](https://json-schema.org/) is a more recent specification than OpenAPI 3.0, which the [Schema](/api/caching#Schema) object is based on. Support for JSON Schema is available as a preview using the field [`responseJsonSchema`](/api/generate-content#FIELDS.response_json_schema) which accepts any JSON Schema with the following limitations:
+
+  * It only works with Gemini 2.5.
+  * While all JSON Schema properties can be passed, not all are supported. See the [documentation](/api/generate-content#FIELDS.response_json_schema) for the field for more details.
+  * Recursive references can only be used as the value of a non-required object property.
+  * Recursive references are unrolled to a finite degree, based on the size of the schema.
+  * Schemas that contain `$ref` cannot contain any properties other than those starting with a `$`.
+
+
+
+Here's an example of generating a JSON Schema with Pydantic and submitting it to the model:
+    
+    
+    curl "https://generativelanguage.googleapis.com/v1alpha/models/\
+    gemini-2.5-flash:generateContent" \
+        -H "x-goog-api-key: $GEMINI_API_KEY"\
+        -H 'Content-Type: application/json' \
+        -d @- <<EOF
+    {
+      "contents": [{
+        "parts":[{
+          "text": "Please give a random example following this schema"
+        }]
+      }],
+      "generationConfig": {
+        "response_mime_type": "application/json",
+        "response_json_schema": $(python3 - << PYEOF
+        from enum import Enum
+        from typing import List, Optional, Union, Set
+        from pydantic import BaseModel, Field, ConfigDict
+        import json
+    
+        class UserRole(str, Enum):
+            ADMIN = "admin"
+            VIEWER = "viewer"
+    
+        class Address(BaseModel):
+            street: str
+            city: str
+    
+        class UserProfile(BaseModel):
+            username: str = Field(description="User's unique name")
+            age: Optional[int] = Field(ge=0, le=120)
+            roles: Set[UserRole] = Field(min_items=1)
+            contact: Union[Address, str]
+            model_config = ConfigDict(title="User Schema")
+    
+        # Generate and print the JSON Schema
+        print(json.dumps(UserProfile.model_json_schema(), indent=2))
+        PYEOF
+        )
+      }
+    }
+    EOF
+    
+
+Passing JSON Schema directly is not yet supported when using the SDK.
+
+## Best practices
+
+Keep the following considerations and best practices in mind when you're using a response schema:
+
+  * The size of your response schema counts towards the input token limit.
+  * By default, fields are optional, meaning the model can populate the fields or skip them. You can set fields as required to force the model to provide a value. If there's insufficient context in the associated input prompt, the model generates responses mainly based on the data it was trained on.
+  * A complex schema can result in an `InvalidArgument: 400` error. Complexity might come from long property names, long array length limits, enums with many values, objects with lots of optional properties, or a combination of these factors.
+
+If you get this error with a valid schema, make one or more of the following changes to resolve the error:
+
+    * Shorten property names or enum names.
+    * Flatten nested arrays.
+    * Reduce the number of properties with constraints, such as numbers with minimum and maximum limits.
+    * Reduce the number of properties with complex constraints, such as properties with complex formats like `date-time`.
+    * Reduce the number of optional properties.
+    * Reduce the number of valid values for enums.
+  * If you aren't seeing the results you expect, add more context to your input prompts or revise your response schema. For example, review the model's response without structured output to see how the model responds. You can then update your response schema so that it better fits the model's output. For additional troubleshooting tips on structured output, see the [troubleshooting guide](/gemini-api/docs/troubleshooting#repetitive-tokens).
+
+
+
+
+## What's next
+
+Now that you've learned how to generate structured output, you might want to try using Gemini API tools:
+
+  * [Function calling](/gemini-api/docs/function-calling)
+  * [Code execution](/gemini-api/docs/code-execution)
+  * [Grounding with Google Search](/gemini-api/docs/grounding)
+
+

documentation_gemini/text_generation.md

@@ -0,0 +1,199 @@
+# Text generation
+
+Source: <https://ai.google.dev/gemini-api/docs/text-generation>
+
+---
+
+The Gemini API can generate text output from various inputs, including text, images, video, and audio, leveraging Gemini models.
+
+Here's a basic example that takes a single text input:
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="How does AI work?"
+    )
+    print(response.text)
+    
+
+## Thinking with Gemini 2.5
+
+2.5 Flash and Pro models have ["thinking"](/gemini-api/docs/thinking) enabled by default to enhance quality, which may take longer to run and increase token usage. 
+
+When using 2.5 Flash, you can disable thinking by setting the thinking budget to zero. 
+
+For more details, see the [thinking guide](/gemini-api/docs/thinking#set-budget).
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents="How does AI work?",
+        config=types.GenerateContentConfig(
+            thinking_config=types.ThinkingConfig(thinking_budget=0) # Disables thinking
+        ),
+    )
+    print(response.text)
+    
+
+## System instructions and other configurations
+
+You can guide the behavior of Gemini models with system instructions. To do so, pass a [`GenerateContentConfig`](/api/generate-content#v1beta.GenerationConfig) object.
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        config=types.GenerateContentConfig(
+            system_instruction="You are a cat. Your name is Neko."),
+        contents="Hello there"
+    )
+    
+    print(response.text)
+    
+
+The [`GenerateContentConfig`](/api/generate-content#v1beta.GenerationConfig) object also lets you override default generation parameters, such as [temperature](/api/generate-content#v1beta.GenerationConfig).
+    
+    
+    from google import genai
+    from google.genai import types
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=["Explain how AI works"],
+        config=types.GenerateContentConfig(
+            temperature=0.1
+        )
+    )
+    print(response.text)
+    
+
+Refer to the [`GenerateContentConfig`](/api/generate-content#v1beta.GenerationConfig) in our API reference for a complete list of configurable parameters and their descriptions.
+
+## Multimodal inputs
+
+The Gemini API supports multimodal inputs, allowing you to combine text with media files. The following example demonstrates providing an image:
+    
+    
+    from PIL import Image
+    from google import genai
+    
+    client = genai.Client()
+    
+    image = Image.open("/path/to/organ.png")
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=[image, "Tell me about this instrument"]
+    )
+    print(response.text)
+    
+
+For alternative methods of providing images and more advanced image processing, see our [image understanding guide](/gemini-api/docs/image-understanding). The API also supports [document](/gemini-api/docs/document-processing), [video](/gemini-api/docs/video-understanding), and [audio](/gemini-api/docs/audio) inputs and understanding.
+
+## Streaming responses
+
+By default, the model returns a response only after the entire generation process is complete.
+
+For more fluid interactions, use streaming to receive [`GenerateContentResponse`](/api/generate-content#v1beta.GenerateContentResponse) instances incrementally as they're generated.
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    
+    response = client.models.generate_content_stream(
+        model="gemini-2.5-flash",
+        contents=["Explain how AI works"]
+    )
+    for chunk in response:
+        print(chunk.text, end="")
+    
+
+## Multi-turn conversations (Chat)
+
+Our SDKs provide functionality to collect multiple rounds of prompts and responses into a chat, giving you an easy way to keep track of the conversation history.
+
+**Note:** Chat functionality is only implemented as part of the SDKs. Behind the scenes, it still uses the [`generateContent`](/api/generate-content#method:-models.generatecontent) API. For multi-turn conversations, the full conversation history is sent to the model with each follow-up turn.
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    chat = client.chats.create(model="gemini-2.5-flash")
+    
+    response = chat.send_message("I have 2 dogs in my house.")
+    print(response.text)
+    
+    response = chat.send_message("How many paws are in my house?")
+    print(response.text)
+    
+    for message in chat.get_history():
+        print(f'role - {message.role}',end=": ")
+        print(message.parts[0].text)
+    
+
+Streaming can also be used for multi-turn conversations.
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    chat = client.chats.create(model="gemini-2.5-flash")
+    
+    response = chat.send_message_stream("I have 2 dogs in my house.")
+    for chunk in response:
+        print(chunk.text, end="")
+    
+    response = chat.send_message_stream("How many paws are in my house?")
+    for chunk in response:
+        print(chunk.text, end="")
+    
+    for message in chat.get_history():
+        print(f'role - {message.role}', end=": ")
+        print(message.parts[0].text)
+    
+
+## Supported models
+
+All models in the Gemini family support text generation. To learn more about the models and their capabilities, visit the [Models](/gemini-api/docs/models) page.
+
+## Best practices
+
+### Prompting tips
+
+For basic text generation, a [zero-shot](/gemini-api/docs/prompting-strategies#few-shot) prompt often suffices without needing examples, system instructions or specific formatting.
+
+For more tailored outputs:
+
+  * Use System instructions to guide the model.
+  * Provide few example inputs and outputs to guide the model. This is often referred to as [few-shot](/gemini-api/docs/prompting-strategies#few-shot) prompting.
+
+
+
+Consult our [prompt engineering guide](/gemini/docs/prompting-strategies) for more tips.
+
+### Structured output
+
+In some cases, you may need structured output, such as JSON. Refer to our [structured output](/gemini-api/docs/structured-output) guide to learn how.
+
+## What's next
+
+  * Try the [Gemini API getting started Colab](https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started.ipynb).
+  * Explore Gemini's [image](/gemini-api/docs/image-understanding), [video](/gemini-api/docs/video-understanding), [audio](/gemini-api/docs/audio) and [document](/gemini-api/docs/document-processing) understanding capabilities.
+  * Learn about multimodal [file prompting strategies](/gemini-api/docs/files#prompt-guide).
+
+

documentation_gemini/url_context.md

@@ -0,0 +1,198 @@
+# URL context
+
+Source: <https://ai.google.dev/gemini-api/docs/url-context>
+
+---
+
+The URL context tool lets you provide additional context to the models in the form of URLs. By including URLs in your request, the model will access the content from those pages (as long as it's not a URL type listed in the limitations section) to inform and enhance its response.
+
+The URL context tool is useful for tasks like the following:
+
+  * **Extract Data** : Pull specific info like prices, names, or key findings from multiple URLs.
+  * **Compare Documents** : Analyze multiple reports, articles, or PDFs to identify differences and track trends.
+  * **Synthesize & Create Content**: Combine information from several source URLs to generate accurate summaries, blog posts, or reports.
+  * **Analyze Code & Docs**: Point to a GitHub repository or technical documentation to explain code, generate setup instructions, or answer questions.
+
+
+
+The following example shows how to compare two recipes from different websites.
+    
+    
+    from google import genai
+    from google.genai.types import Tool, GenerateContentConfig
+    
+    client = genai.Client()
+    model_id = "gemini-2.5-flash"
+    
+    tools = [
+      {"url_context": {}},
+    ]
+    
+    url1 = "https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592"
+    url2 = "https://www.allrecipes.com/recipe/21151/simple-whole-roast-chicken/"
+    
+    response = client.models.generate_content(
+        model=model_id,
+        contents=f"Compare the ingredients and cooking times from the recipes at {url1} and {url2}",
+        config=GenerateContentConfig(
+            tools=tools,
+        )
+    )
+    
+    for each in response.candidates[0].content.parts:
+        print(each.text)
+    
+    # For verification, you can inspect the metadata to see which URLs the model retrieved
+    print(response.candidates[0].url_context_metadata)
+    
+
+## How it works
+
+The URL Context tool uses a two-step retrieval process to balance speed, cost, and access to fresh data. When you provide a URL, the tool first attempts to fetch the content from an internal index cache. This acts as a highly optimized cache. If a URL is not available in the index (for example, if it's a very new page), the tool automatically falls back to do a live fetch. This directly accesses the URL to retrieve its content in real-time.
+
+## Combining with other tools
+
+You can combine the URL context tool with other tools to create more powerful workflows.
+
+### Grounding with search
+
+When both URL context and [Grounding with Google Search](/gemini-api/docs/grounding) are enabled, the model can use its search capabilities to find relevant information online and then use the URL context tool to get a more in-depth understanding of the pages it finds. This approach is powerful for prompts that require both broad searching and deep analysis of specific pages.
+    
+    
+    from google import genai
+    from google.genai.types import Tool, GenerateContentConfig, GoogleSearch, UrlContext
+    
+    client = genai.Client()
+    model_id = "gemini-2.5-flash"
+    
+    tools = [
+          {"url_context": {}},
+          {"google_search": {}}
+      ]
+    
+    response = client.models.generate_content(
+        model=model_id,
+        contents="Give me three day events schedule based on YOUR_URL. Also let me know what needs to taken care of considering weather and commute.",
+        config=GenerateContentConfig(
+            tools=tools,
+        )
+    )
+    
+    for each in response.candidates[0].content.parts:
+        print(each.text)
+    # get URLs retrieved for context
+    print(response.candidates[0].url_context_metadata)
+    
+    
+
+## Understanding the response
+
+When the model uses the URL context tool, the response includes a `url_context_metadata` object. This object lists the URLs the model retrieved content from and the status of each retrieval attempt, which is useful for verification and debugging.
+
+The following is an example of that part of the response (parts of the response have been omitted for brevity):
+    
+    
+    {
+      "candidates": [
+        {
+          "content": {
+            "parts": [
+              {
+                "text": "... \n"
+              }
+            ],
+            "role": "model"
+          },
+          ...
+          "url_context_metadata": {
+            "url_metadata": [
+              {
+                "retrieved_url": "https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592",
+                "url_retrieval_status": "URL_RETRIEVAL_STATUS_SUCCESS"
+              },
+              {
+                "retrieved_url": "https://www.allrecipes.com/recipe/21151/simple-whole-roast-chicken/",
+                "url_retrieval_status": "URL_RETRIEVAL_STATUS_SUCCESS"
+              }
+            ]
+          }
+        }
+    }
+    
+
+For complete detail about this object , see the [`UrlContextMetadata` API reference](/api/generate-content#UrlContextMetadata).
+
+### Safety checks
+
+The system performs a content moderation check on the URL to confirm they meet safety standards. If the URL you provided fails this check, you will get an `url_retrieval_status` of `URL_RETRIEVAL_STATUS_UNSAFE`.
+
+### Token count
+
+The content retrieved from the URLs you specify in your prompt is counted as part of the input tokens. You can see the token count for your prompt and tools usage in the [`usage_metadata`](/api/generate-content#UsageMetadata) object of the model output. The following is an example output:
+    
+    
+    'usage_metadata': {
+      'candidates_token_count': 45,
+      'prompt_token_count': 27,
+      'prompt_tokens_details': [{'modality': <MediaModality.TEXT: 'TEXT'>,
+        'token_count': 27}],
+      'thoughts_token_count': 31,
+      **'tool_use_prompt_token_count': 10309,**
+      'tool_use_prompt_tokens_details': [{'modality': <MediaModality.TEXT: 'TEXT'>,
+        'token_count': 10309}],
+      'total_token_count': 10412
+      }
+    
+
+Price per token depends on the model used, see the [pricing](/gemini-api/docs/pricing) page for details.
+
+## Supported models
+
+  * [gemini-2.5-pro](/gemini-api/docs/models#gemini-2.5-pro)
+  * [gemini-2.5-flash](/gemini-api/docs/models#gemini-2.5-flash)
+  * [gemini-2.5-flash-lite](/gemini-api/docs/models#gemini-2.5-flash-lite)
+  * [gemini-live-2.5-flash-preview](/gemini-api/docs/models#live-api)
+  * [gemini-2.0-flash-live-001](/gemini-api/docs/models#live-api-2.0)
+
+
+
+## Best Practices
+
+  * **Provide specific URLs** : For the best results, provide direct URLs to the content you want the model to analyze. The model will only retrieve content from the URLs you provide, not any content from nested links.
+  * **Check for accessibility** : Verify that the URLs you provide don't lead to pages that require a login or are behind a paywall.
+  * **Use the complete URL** : Provide the full URL, including the protocol (e.g., https://www.google.com instead of just google.com).
+
+
+
+## Limitations
+
+  * **Pricing** : Content retrieved from URLs counts as input tokens. Rate limit and pricing is the based on the model used. See the [rate limits](/gemini-api/docs/rate-limits) and [pricing](/gemini-api/docs/pricing) pages for details.
+  * **Request limit** : The tool can process up to 20 URLs per request.
+  * **URL content size** : The maximum size for content retrieved from a single URL is 34MB.
+
+
+
+### Supported and unsupported content types
+
+The tool can extract content from URLs with the following content types:
+
+  * Text (text/html, application/json, text/plain, text/xml, text/css, text/javascript , text/csv, text/rtf)
+  * Image (image/png, image/jpeg, image/bmp, image/webp)
+  * PDF (application/pdf)
+
+
+
+The following content types are **not** supported:
+
+  * Paywalled content
+  * YouTube videos (See [video understanding](/gemini-api/docs/video-understanding#youtube) to learn how to process YouTube URLs)
+  * Google workspace files like Google docs or spreadsheets
+  * Video and audio files
+
+
+
+## What's next
+
+  * Explore the [URL context cookbook](https://colab.sandbox.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Grounding.ipynb#url-context) for more examples.
+
+

documentation_gemini/video_understanding.md

@@ -0,0 +1,224 @@
+# Video understanding
+
+Source: <https://ai.google.dev/gemini-api/docs/video-understanding>
+
+---
+
+Gemini models can process videos, enabling many frontier developer use cases that would have historically required domain specific models. Some of Gemini's vision capabilities include the ability to:
+
+  * Describe, segment, and extract information from videos
+  * Answer questions about video content
+  * Refer to specific timestamps within a video
+
+
+
+Gemini was built to be multimodal from the ground up and we continue to push the frontier of what is possible. This guide shows how to use the Gemini API to generate text responses based on video inputs.
+
+## Video input
+
+You can provide videos as input to Gemini in the following ways:
+
+  * Upload a video file using the File API before making a request to `generateContent`. Use this method for files larger than 20MB, videos longer than approximately 1 minute, or when you want to reuse the file across multiple requests.
+  * Pass inline video data with the request to `generateContent`. Use this method for smaller files (<20MB) and shorter durations.
+  * Include a YouTube URL directly in the prompt.
+
+
+
+### Upload a video file
+
+You can use the [Files API](/gemini-api/docs/files) to upload a video file. Always use the Files API when the total request size (including the file, text prompt, system instructions, etc.) is larger than 20 MB, the video duration is significant, or if you intend to use the same video in multiple prompts. The File API accepts video file formats directly.
+
+The following code downloads the sample video, uploads it using the File API, waits for it to be processed, and then uses the file reference in a `generateContent` request.
+    
+    
+    from google import genai
+    
+    client = genai.Client()
+    
+    myfile = client.files.upload(file="path/to/sample.mp4")
+    
+    response = client.models.generate_content(
+        model="gemini-2.5-flash", contents=[myfile, "Summarize this video. Then create a quiz with an answer key based on the information in this video."]
+    )
+    
+    print(response.text)
+    
+
+To learn more about working with media files, see [Files API](/gemini-api/docs/files).
+
+### Pass video data inline
+
+Instead of uploading a video file using the File API, you can pass smaller videos directly in the request to `generateContent`. This is suitable for shorter videos under 20MB total request size.
+
+Here's an example of providing inline video data:
+    
+    
+    # Only for videos of size <20Mb
+    video_file_name = "/path/to/your/video.mp4"
+    video_bytes = open(video_file_name, 'rb').read()
+    
+    response = client.models.generate_content(
+        model='models/gemini-2.5-flash',
+        contents=types.Content(
+            parts=[
+                types.Part(
+                    inline_data=types.Blob(data=video_bytes, mime_type='video/mp4')
+                ),
+                types.Part(text='Please summarize the video in 3 sentences.')
+            ]
+        )
+    )
+    
+
+### Include a YouTube URL
+
+**Preview:** The YouTube URL feature is in preview and is available at no charge. Pricing and rate limits are likely to change.
+
+The Gemini API and AI Studio support YouTube URLs as a file data `Part`. You can include a YouTube URL with a prompt asking the model to summarize, translate, or otherwise interact with the video content.
+
+**Limitations:**
+
+  * For the free tier, you can't upload more than 8 hours of YouTube video per day.
+  * For the paid tier, there is no limit based on video length.
+  * For models before 2.5, you can upload only 1 video per request. For models after 2.5, you can upload a maximum of 10 videos per request.
+  * You can only upload public videos (not private or unlisted videos).
+
+
+
+The following example shows how to include a YouTube URL with a prompt:
+    
+    
+    response = client.models.generate_content(
+        model='models/gemini-2.5-flash',
+        contents=types.Content(
+            parts=[
+                types.Part(
+                    file_data=types.FileData(file_uri='https://www.youtube.com/watch?v=9hE5-98ZeCg')
+                ),
+                types.Part(text='Please summarize the video in 3 sentences.')
+            ]
+        )
+    )
+    
+
+## Refer to timestamps in the content
+
+You can ask questions about specific points in time within the video using timestamps of the form `MM:SS`.
+    
+    
+    prompt = "What are the examples given at 00:05 and 00:10 supposed to show us?" # Adjusted timestamps for the NASA video
+    
+
+## Transcribe video and provide visual descriptions
+
+The Gemini models can transcribe and provide visual descriptions of video content by processing both the audio track and visual frames. For visual descriptions, the model samples the video at a rate of **1 frame per second**. This sampling rate may affect the level of detail in the descriptions, particularly for videos with rapidly changing visuals.
+    
+    
+    prompt = "Transcribe the audio from this video, giving timestamps for salient events in the video. Also provide visual descriptions."
+    
+
+## Customize video processing
+
+You can customize video processing in the Gemini API by setting clipping intervals or providing custom frame rate sampling.
+
+**Tip:** Video clipping and frames per second (FPS) are supported by all models, but the quality is significantly higher from 2.5 series models.
+
+### Set clipping intervals
+
+You can clip video by specifying `videoMetadata` with start and end offsets.
+    
+    
+    response = client.models.generate_content(
+        model='models/gemini-2.5-flash',
+        contents=types.Content(
+            parts=[
+                types.Part(
+                    file_data=types.FileData(file_uri='https://www.youtube.com/watch?v=XEzRZ35urlk'),
+                    video_metadata=types.VideoMetadata(
+                        start_offset='1250s',
+                        end_offset='1570s'
+                    )
+                ),
+                types.Part(text='Please summarize the video in 3 sentences.')
+            ]
+        )
+    )
+    
+
+### Set a custom frame rate
+
+You can set custom frame rate sampling by passing an `fps` argument to `videoMetadata`.
+
+**Note:** Due to built-in per image based safety checks, the same video may get blocked at some fps and not at others due to different extracted frames.
+    
+    
+    # Only for videos of size <20Mb
+    video_file_name = "/path/to/your/video.mp4"
+    video_bytes = open(video_file_name, 'rb').read()
+    
+    response = client.models.generate_content(
+        model='models/gemini-2.5-flash',
+        contents=types.Content(
+            parts=[
+                types.Part(
+                    inline_data=types.Blob(
+                        data=video_bytes,
+                        mime_type='video/mp4'),
+                    video_metadata=types.VideoMetadata(fps=5)
+                ),
+                types.Part(text='Please summarize the video in 3 sentences.')
+            ]
+        )
+    )
+    
+
+By default 1 frame per second (FPS) is sampled from the video. You might want to set low FPS (< 1) for long videos. This is especially useful for mostly static videos (e.g. lectures). If you want to capture more details in rapidly changing visuals, consider setting a higher FPS value.
+
+## Supported video formats
+
+Gemini supports the following video format MIME types:
+
+  * `video/mp4`
+  * `video/mpeg`
+  * `video/mov`
+  * `video/avi`
+  * `video/x-flv`
+  * `video/mpg`
+  * `video/webm`
+  * `video/wmv`
+  * `video/3gpp`
+
+
+
+## Technical details about videos
+
+  * **Supported models & context**: All Gemini 2.0 and 2.5 models can process video data. 
+    * Models with a 2M context window can process videos up to 2 hours long at default media resolution or 6 hours long at low media resolution, while models with a 1M context window can process videos up to 1 hour long at default media resolution or 3 hours long at low media resolution.
+  * **File API processing** : When using the File API, videos are stored at 1 frame per second (FPS) and audio is processed at 1Kbps (single channel). Timestamps are added every second. 
+    * These rates are subject to change in the future for improvements in inference.
+    * You can override the 1 FPS sampling rate by setting a custom frame rate.
+  * **Token calculation** : Each second of video is tokenized as follows: 
+    * Individual frames (sampled at 1 FPS): 
+      * If [`mediaResolution`](/api/generate-content#MediaResolution) is set to low, frames are tokenized at 66 tokens per frame.
+      * Otherwise, frames are tokenized at 258 tokens per frame.
+    * Audio: 32 tokens per second.
+    * Metadata is also included.
+    * Total: Approximately 300 tokens per second of video at default media resolution, or 100 tokens per second of video at low media resolution.
+  * **Timestamp format** : When referring to specific moments in a video within your prompt, use the `MM:SS` format (e.g., `01:15` for 1 minute and 15 seconds).
+  * **Best practices** : 
+    * Use only one video per prompt request for optimal results.
+    * If combining text and a single video, place the text prompt _after_ the video part in the `contents` array.
+    * Be aware that fast action sequences might lose detail due to the 1 FPS sampling rate. Consider slowing down such clips if necessary.
+
+
+
+## What's next
+
+This guide shows how to upload video files and generate text outputs from video inputs. To learn more, see the following resources:
+
+  * [System instructions](/gemini-api/docs/text-generation#system-instructions): System instructions let you steer the behavior of the model based on your specific needs and use cases.
+  * [Files API](/gemini-api/docs/files): Learn more about uploading and managing files for use with Gemini.
+  * [File prompting strategies](/gemini-api/docs/files#prompt-guide): The Gemini API supports prompting with text, image, audio, and video data, also known as multimodal prompting.
+  * [Safety guidance](/gemini-api/docs/safety-guidance): Sometimes generative AI models produce unexpected outputs, such as outputs that are inaccurate, biased, or offensive. Post-processing and human evaluation are essential to limit the risk of harm from such outputs.
+
+

templates/index.html

@@ -181,6 +181,33 @@
             const formData = new FormData();
             formData.append('file', file);
 
+            // Show immediate preview for images
+            if (file.type.startsWith('image/')) {
+                const reader = new FileReader();
+                reader.onload = function(e) {
+                    filePreview.innerHTML = `
+                        <div class="flex items-center gap-3">
+                            <img src="${e.target.result}" alt="${file.name}" class="w-16 h-16 object-cover rounded-lg border border-gray-600">
+                            <div class="flex-1">
+                                <div class="text-gray-300 text-sm font-medium">${file.name}</div>
+                                <div class="text-gray-500 text-xs">${(file.size / 1024).toFixed(1)} KB</div>
+                            </div>
+                            <button onclick="removeFile()" class="bg-gray-600 hover:bg-gray-500 text-white px-3 py-1 rounded transition-colors">✕</button>
+                        </div>
+                    `;
+                    filePreview.classList.remove('hidden');
+                };
+                reader.readAsDataURL(file);
+            } else {
+                filePreview.innerHTML = `
+                    <div class="flex justify-between items-center">
+                        <span class="text-gray-300">📎 ${file.name}</span>
+                        <button onclick="removeFile()" class="bg-gray-600 hover:bg-gray-500 text-white px-3 py-1 rounded transition-colors">✕</button>
+                    </div>
+                `;
+                filePreview.classList.remove('hidden');
+            }
+
             fetch('/upload', {
                 method: 'POST',
                 body: formData
@@ -189,19 +216,14 @@
             .then(data => {
                 if (data.success) {
                     currentFile = data;
-                    filePreview.innerHTML = `
-                        <div class="flex justify-between items-center">
-                            <span class="text-gray-300">📎 ${data.filename}</span>
-                            <button onclick="removeFile()" class="bg-gray-600 hover:bg-gray-500 text-white px-3 py-1 rounded transition-colors">✕</button>
-                        </div>
-                    `;
-                    filePreview.classList.remove('hidden');
                 } else {
                     showError('Erreur lors du téléchargement: ' + data.error);
+                    filePreview.classList.add('hidden');
                 }
             })
             .catch(error => {
                 showError('Erreur lors du téléchargement: ' + error.message);
+                filePreview.classList.add('hidden');
             });
         }
 
@@ -223,8 +245,8 @@
             messageInput.disabled = true;
             sendButton.disabled = true;
             
-            if (message) {
-                addMessage('user', message);
+            if (message || currentFile) {
+                addMessage('user', message, currentFile);
             }
             
             typingIndicator.classList.remove('hidden');
@@ -330,19 +352,30 @@
             });
         }
 
-        function addMessage(role, content) {
+        function addMessage(role, content, fileData = null) {
             const messagesContainer = document.getElementById('messages');
             const messageDiv = document.createElement('div');
-            
+
+            let messageContent = '';
+
+            if (fileData && fileData.mime_type && fileData.mime_type.startsWith('image/')) {
+                const imageUrl = `data:${fileData.mime_type};base64,${fileData.data}`;
+                messageContent += `<img src="${imageUrl}" alt="${fileData.filename}" class="max-w-full h-auto rounded-lg mb-2 border border-gray-600">`;
+            }
+
+            if (content) {
+                const markdownHtml = marked.parse(content);
+                messageContent += `<div class="markdown-content">${markdownHtml}</div>`;
+            }
+
             if (role === 'user') {
                 messageDiv.className = 'max-w-[85%] p-4 rounded-2xl bg-gray-600 text-gray-100 self-end rounded-br-sm animate-fade-in';
-                const markdownHtml = marked.parse(content);
-                messageDiv.innerHTML = `<div class="markdown-content">${markdownHtml}</div>`;
             } else {
                 messageDiv.className = 'max-w-[85%] p-4 rounded-2xl bg-dark-elevated text-gray-200 self-start rounded-bl-sm animate-fade-in';
-                messageDiv.innerHTML = `<div class="markdown-content">${content}</div>`;
             }
-            
+
+            messageDiv.innerHTML = messageContent;
+
             messagesContainer.appendChild(messageDiv);
             messagesContainer.scrollTop = messagesContainer.scrollHeight;
             return messageDiv;