Gemini 2.5 Pro API : Un guide avec un projet de démonstration

Connexion à l'API de Gemini 2.5 Pro

Pour accéder au modèle Gemini 2.5 Pro via l'API Google, procédez comme suit :

1. Mise en place

Commencez par installer le paquetage Python google-genai. Exécutez la commande suivante dans votre terminal :

pip install google-genai

2. Générer une clé API

Aller à Google AI Studio et générez votre clé API. Ensuite, définissez la clé API en tant que variable d'environnement dans votre système.

3. Créer le client GenAI

Utilisez la clé API pour initialiser le client Google GenAI. Ce client vous permettra d'interagir avec le modèle Gemini 2.5 Pro.

import os
from google import genai
from google.genai import types
from IPython.display import Markdown, HTML, Image, display

API_KEY = os.environ.get("GEMINI_API_KEY")

client = genai.Client(api_key=API_KEY)

4. Charger le fichier

Chargez le fichier Python avec lequel vous souhaitez travailler et créez une invite pour le modèle.

# Load the Python file as text

file_path = "secure_app.py"
with open(file_path, "r") as file:
    doc_data = file.read()
prompt = "Please integrate user management into the FastAPI application."

contents = [
    types.Part.from_bytes(
        data=doc_data.encode("utf-8"),
        mime_type="text/x-python",
    ),
    prompt,
]

5. Générer une réponse

Créez une instance de chat en utilisant le modèle Gemini 2.5 Pro (gemini-2.5-pro-exp-03-25) et fournissez-lui le contenu du fichier et l'invite. Le modèle analyse le code et génère une réponse.

chat = client.aio.chats.create(
    model="gemini-2.5-pro-exp-03-25",
    config=types.GenerateContentConfig(
        tools=[types.Tool(code_execution=types.ToolCodeExecution)]
    ),
)

response = await chat.send_message(contents)
Markdown(response.text)

En quelques secondes, la réponse contextuelle a été générée.

Note : L'accès gratuit au modèle peut ne pas être disponible actuellement en raison d'une charge importante. Attendez quelques minutes et réessayez.

6. Exécution du code (expérimental)

Vous pouvez également demander au modèle d'exécuter le code.

response = await chat.send_message('Please run the code to ensure that everything is functioning properly.')
Markdown(response.text)

Notez que cette fonctionnalité est expérimentale et qu'elle a des limites. Par exemple, le modèle ne peut pas exécuter de serveurs web, accéder au système de fichiers ou effectuer des opérations sur le réseau.

Note : Le modèle Gemini 2.5 Pro comprend des capacités de "réflexion" avancées. Bien qu'ils soient visibles dans Google AI Studio, ils ne sont pas inclus dans les résultats de l'API.

Construire une application d'analyse de code avec Gemini 2.5 Pro

Cette application permet aux utilisateurs de télécharger des fichiers, y compris des fichiers multiples ou même une archive ZIP contenant un projet entier, vers une interface basée sur le chat. Les utilisateurs peuvent poser des questions sur leur projet, résoudre des problèmes ou améliorer leur base de code. Contrairement aux éditeurs de code IA traditionnels qui, en raison de leurs limitations, ont du mal à gérer les contextes de grande taille, Gemini 2.5 Pro, avec sa longue fenêtre de contexte, peut analyser et résoudre efficacement les problèmes dans l'ensemble d'un projet.

1. Installation des bibliothèques nécessaires

Installez gradio pour la création de l'interface utilisateur et zipfile36 pour la gestion des fichiers ZIP.

pip install gradio==5.14.0
pip install zipfile36==0.1.3

2. Configuration du client et de l'interface utilisateur

Importez les paquets Python nécessaires, définissez les variables globales, initialisez le client GenAI, configurez les constantes de l'interface utilisateur et créez une liste des extensions de fichiers prises en charge.

import os
import zipfile
from typing import Dict, List, Optional, Union

import gradio as gr
from google import genai
from google.genai import types

# Retrieve API key for Google GenAI from the environment variables.
GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")

# Initialize the client so that it can be reused across functions.
CLIENT = genai.Client(api_key=GOOGLE_API_KEY)


# Global variables
EXTRACTED_FILES = {}

# Store chat sessions
CHAT_SESSIONS = {}

TITLE = """<h1 align="center">✨ Gemini Code Analysis</h1>"""
AVATAR_IMAGES = (None, "https://media.roboflow.com/spaces/gemini-icon.png")


# List of supported text extensions (alphabetically sorted)
TEXT_EXTENSIONS = [
    ".bat",
    ".c",
    ".cfg",
    ".conf",
    ".cpp",
    ".cs",
    ".css",
    ".go",
    ".h",
    ".html",
    ".ini",
    ".java",
    ".js",
    ".json",
    ".jsx",
    ".md",
    ".php",
    ".ps1",
    ".py",
    ".rb",
    ".rs",
    ".sh",
    ".toml",
    ".ts",
    ".tsx",
    ".txt",
    ".xml",
    ".yaml",
    ".yml",
]

3. Fonction : extract_text_from_zip

La fonction extract_text_from_zip() extrait le contenu textuel des fichiers à l'intérieur d'une archive ZIP et le renvoie sous forme de dictionnaire.

def extract_text_from_zip(zip_file_path: str) -> Dict[str, str]:

    text_contents = {}

    with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
        for file_info in zip_ref.infolist():
            # Skip directories
            if file_info.filename.endswith("/"):
                continue

            # Skip binary files and focus on text files
            file_ext = os.path.splitext(file_info.filename)[1].lower()

            if file_ext in TEXT_EXTENSIONS:
                try:
                    with zip_ref.open(file_info) as file:
                        content = file.read().decode("utf-8", errors="replace")
                        text_contents[file_info.filename] = content
                except Exception as e:
                    text_contents[file_info.filename] = (
                        f"Error extracting file: {str(e)}"
                    )

    return text_contents

4. Fonction : extract_text_from_single_file

La fonction extract_text_from_single_file() extrait le contenu textuel d'un fichier unique et le renvoie sous forme de dictionnaire.

def extract_text_from_single_file(file_path: str) -> Dict[str, str]:

    text_contents = {}
    filename = os.path.basename(file_path)
    file_ext = os.path.splitext(filename)[1].lower()

    if file_ext in TEXT_EXTENSIONS:
        try:
            with open(file_path, "r", encoding="utf-8", errors="replace") as file:
                content = file.read()
                text_contents[filename] = content
        except Exception as e:
            text_contents[filename] = f"Error reading file: {str(e)}"

    return text_contents

5. Fonction : upload_zip

La fonction upload_zip() traite les fichiers téléchargés, qu'ils soient au format ZIP ou au format texte, extrait le contenu du texte et ajoute un message au chat.

def upload_zip(files: Optional[List[str]], chatbot: List[Union[dict, gr.ChatMessage]]):
    global EXTRACTED_FILES

    # Handle multiple file uploads
    if len(files) > 1:
        total_files_processed = 0
        total_files_extracted = 0
        file_types = set()

        # Process each file
        for file in files:
            filename = os.path.basename(file)
            file_ext = os.path.splitext(filename)[1].lower()

            # Process based on file type
            if file_ext == ".zip":
                extracted_files = extract_text_from_zip(file)
                file_types.add("zip")
            else:
                extracted_files = extract_text_from_single_file(file)
                file_types.add("text")

            if extracted_files:
                total_files_extracted += len(extracted_files)
                # Store the extracted content in the global variable
                EXTRACTED_FILES[filename] = extracted_files

            total_files_processed += 1

        # Create a summary message for multiple files
        file_types_str = (
            "files"
            if len(file_types) > 1
            else ("ZIP files" if "zip" in file_types else "text files")
        )

        # Create a list of uploaded file names
        file_list = "\n".join([f"- {os.path.basename(file)}" for file in files])

        chatbot.append(
            gr.ChatMessage(
                role="user",
                content=f"<p>📚 Multiple {file_types_str} uploaded ({total_files_processed} files)</p><p>Extracted {total_files_extracted} text file(s) in total</p><p>Uploaded files:</p><pre>{file_list}</pre>",
            )
        )

    # Handle single file upload (original behavior)
    elif len(files) == 1:
        file = files[0]
        filename = os.path.basename(file)
        file_ext = os.path.splitext(filename)[1].lower()

        # Process based on file type
        if file_ext == ".zip":
            extracted_files = extract_text_from_zip(file)
            file_type_msg = "📦 ZIP file"
        else:
            extracted_files = extract_text_from_single_file(file)
            file_type_msg = "📄 File"

        if not extracted_files:
            chatbot.append(
                gr.ChatMessage(
                    role="user",
                    content=f"<p>{file_type_msg} uploaded: {filename}, but no text content was found or the file format is not supported.</p>",
                )
            )
        else:
            file_list = "\n".join([f"- {name}" for name in extracted_files.keys()])
            chatbot.append(
                gr.ChatMessage(
                    role="user",
                    content=f"<p>{file_type_msg} uploaded: {filename}</p><p>Extracted {len(extracted_files)} text file(s):</p><pre>{file_list}</pre>",
                )
            )

            # Store the extracted content in the global variable
            EXTRACTED_FILES[filename] = extracted_files

    return chatbot

6. Fonction : utilisateur

La fonction user() ajoute le texte saisi par l'utilisateur à l'historique des conversations du chatbot.

def user(text_prompt: str, chatbot: List[gr.ChatMessage]):

    if text_prompt:
        chatbot.append(gr.ChatMessage(role="user", content=text_prompt))
    return "", chatbot

7. Fonction : get_message_content

La fonction get_message_content() permet de récupérer le contenu d'un message, qui peut être un dictionnaire ou un message de chat Gradio.

def get_message_content(msg):
   
    if isinstance(msg, dict):
        return msg.get("content", "")
    return msg.content

8. Fonction : send_to_gemini

La fonction send_to_gemini() envoie l'invite de l'utilisateur à Gemini AI et renvoie la réponse au chatbot. Si des fichiers de code ont été téléchargés, ils seront inclus dans le contexte.

def send_to_gemini(chatbot: List[Union[dict, gr.ChatMessage]]):

    global EXTRACTED_FILES, CHAT_SESSIONS

    if len(chatbot) == 0:
        chatbot.append(
            gr.ChatMessage(
                role="assistant",
                content="Please enter a message to start the conversation.",
            )
        )
        return chatbot

    # Get the last user message as the prompt
    user_messages = [
        msg
        for msg in chatbot
        if (isinstance(msg, dict) and msg.get("role") == "user")
        or (hasattr(msg, "role") and msg.role == "user")
    ]

    if not user_messages:
        chatbot.append(
            gr.ChatMessage(
                role="assistant",
                content="Please enter a message to start the conversation.",
            )
        )
        return chatbot

    last_user_msg = user_messages[-1]
    prompt = get_message_content(last_user_msg)

    # Skip if the last message was about uploading a file (ZIP, single file, or multiple files)
    if (
        "📦 ZIP file uploaded:" in prompt
        or "📄 File uploaded:" in prompt
        or "📚 Multiple files uploaded" in prompt
    ):
        chatbot.append(
            gr.ChatMessage(
                role="assistant",
                content="What would you like to know about the code in this ZIP file?",
            )
        )
        return chatbot

    # Generate a unique session ID based on the extracted files or use a default key for no files
    if EXTRACTED_FILES:
        session_key = ",".join(sorted(EXTRACTED_FILES.keys()))
    else:
        session_key = "no_files"

    # Create a new chat session if one doesn't exist for this set of files
    if session_key not in CHAT_SESSIONS:
        # Configure Gemini with code execution capability
        CHAT_SESSIONS[session_key] = CLIENT.chats.create(
            model="gemini-2.5-pro-exp-03-25",
        )

        # Send all extracted files to the chat session first
        initial_contents = []
        for zip_name, files in EXTRACTED_FILES.items():
            for filename, content in files.items():
                file_ext = os.path.splitext(filename)[1].lower()
                mime_type = "text/plain"

                # Set appropriate mime type based on file extension
                if file_ext == ".py":
                    mime_type = "text/x-python"
                elif file_ext in [".js", ".jsx"]:
                    mime_type = "text/javascript"
                elif file_ext in [".ts", ".tsx"]:
                    mime_type = "text/typescript"
                elif file_ext == ".html":
                    mime_type = "text/html"
                elif file_ext == ".css":
                    mime_type = "text/css"
                elif file_ext in [".json", ".jsonl"]:
                    mime_type = "application/json"
                elif file_ext in [".xml", ".svg"]:
                    mime_type = "application/xml"

                # Create a header with the filename to preserve original file identity
                file_header = f"File: {filename}\n\n"
                file_content = file_header + content

                initial_contents.append(
                    types.Part.from_bytes(
                        data=file_content.encode("utf-8"),
                        mime_type=mime_type,
                    )
                )

        # Initialize the chat context with files if available
        if initial_contents:
            initial_contents.append(
                "I've uploaded these code files for you to analyze. I'll ask questions about them next."
            )
            # Use synchronous API instead of async
            CHAT_SESSIONS[session_key].send_message(initial_contents)
        # For sessions without files, we don't need to send an initial message

    # Append a placeholder for the assistant's response
    chatbot.append(gr.ChatMessage(role="assistant", content=""))

    # Send the user's prompt to the existing chat session using streaming API
    response = CHAT_SESSIONS[session_key].send_message_stream(prompt)

    # Process the response stream - text only (no images)
    output_text = ""
    for chunk in response:
        if chunk.candidates and chunk.candidates[0].content.parts:
            for part in chunk.candidates[0].content.parts:
                if part.text is not None:
                    # Append the new chunk of text
                    output_text += part.text

                    # Update the last assistant message with the current accumulated response
                    if isinstance(chatbot[-1], dict):
                        chatbot[-1]["content"] = output_text
                    else:
                        chatbot[-1].content = output_text

                    # Yield the updated chatbot to show streaming updates in the UI
                    yield chatbot

    # Return the final chatbot state
    return chatbot

9. Fonction : reset_app

La fonction rest_app() réinitialise l'application en effaçant l'historique des chats et tous les fichiers téléchargés.

def reset_app(chatbot):
    global EXTRACTED_FILES, CHAT_SESSIONS

    # Clear the global variables
    EXTRACTED_FILES = {}
    CHAT_SESSIONS = {}

    # Reset the chatbot with a welcome message
    return [
        gr.ChatMessage(
            role="assistant",
            content="App has been reset. You can start a new conversation or upload new files.",
        )
    ]

10. Composants de l'interface utilisateur de Gradio

Définissons les composants de Gradio : chatbot, entrée de texte, bouton de téléchargement et boutons de contrôle.

# Define the Gradio UI components
chatbot_component = gr.Chatbot(
    label="Gemini 2.5 Pro",
    type="messages",
    bubble_full_width=False,
    avatar_images=AVATAR_IMAGES,
    scale=2,
    height=350,
)
text_prompt_component = gr.Textbox(
    placeholder="Ask a question or upload code files to analyze...",
    show_label=False,
    autofocus=True,
    scale=28,
)
upload_zip_button_component = gr.UploadButton(
    label="Upload",
    file_count="multiple",
    file_types=[".zip"] + TEXT_EXTENSIONS,
    scale=1,
    min_width=80,
)

send_button_component = gr.Button(
    value="Send", variant="primary", scale=1, min_width=80
)
reset_button_component = gr.Button(
    value="Reset", variant="stop", scale=1, min_width=80
)

# Define input lists for button chaining
user_inputs = [text_prompt_component, chatbot_component]

11. Présentation de l'application Gradio

Structurons l'interface de Gradio en utilisant des lignes et des colonnes pour une mise en page claire.

with gr.Blocks(theme=gr.themes.Ocean()) as demo:
    gr.HTML(TITLE)
    with gr.Column():
        chatbot_component.render()
        with gr.Row(equal_height=True):
            text_prompt_component.render()
            send_button_component.render()
            upload_zip_button_component.render()
            reset_button_component.render()

    # When the Send button is clicked, first process the user text then send to Gemini
    send_button_component.click(
        fn=user,
        inputs=user_inputs,
        outputs=[text_prompt_component, chatbot_component],
        queue=False,
    ).then(
        fn=send_to_gemini,
        inputs=[chatbot_component],
        outputs=[chatbot_component],
        api_name="send_to_gemini",
    )

    # Allow submission using the Enter key
    text_prompt_component.submit(
        fn=user,
        inputs=user_inputs,
        outputs=[text_prompt_component, chatbot_component],
        queue=False,
    ).then(
        fn=send_to_gemini,
        inputs=[chatbot_component],
        outputs=[chatbot_component],
        api_name="send_to_gemini_submit",
    )

    # Handle ZIP file uploads
    upload_zip_button_component.upload(
        fn=upload_zip,
        inputs=[upload_zip_button_component, chatbot_component],
        outputs=[chatbot_component],
        queue=False,
    )

    # Handle Reset button clicks
    reset_button_component.click(
        fn=reset_app,
        inputs=[chatbot_component],
        outputs=[chatbot_component],
        queue=False,
    )

12. Lancement de l'application

Lançons l'application Gradio localement avec la file d'attente activée pour gérer les demandes multiples.

# Launch the demo interface
demo.queue(max_size=99, api_open=False).launch(
    debug=False,
    show_error=True,
    server_port=9595,
    server_name="localhost",
)

Test de l'application d'analyse de code Gemini 2.5 Pro

Pour lancer l'application web, combinez toutes les sources de code ci-dessus dans le fichier main.py (que j'ai téléchargé sur GitHub pour que vous puissiez le copier plus facilement). Exécutez-la avec la commande suivante :

python main.py

L'application web sera disponible à l'URL : http://localhost:9595/

Vous pouvez copier l'URL et la coller dans votre navigateur web.

Comme nous pouvons le voir, l'application web est dotée d'une interface de chatbot. Nous pouvons l'utiliser comme le ChatGPT.

Le bouton "Télécharger" permet de télécharger un ou plusieurs fichiers, ainsi que des fichiers zip pour votre projet. Ne vous inquiétez donc pas si votre projet contient plus de 20 fichiers ; l'application d'analyse de code sera en mesure de les traiter et de les envoyer à l'API Gemini 2.5 Pro.

Chargeons plusieurs fichiers et demandons à Gemini 2.5 Pro d'améliorer notre projet. 

Comme nous pouvons le constater, le modèle fournit des suggestions d'amélioration correctes.

Nous pouvons lui demander de mettre en œuvre toutes les suggestions dans le fichier secure_app.py.

Si vous souhaitez travailler sur un autre projet, vous pouvez cliquer sur le bouton "Réinitialiser" et commencer à discuter du nouveau projet.

Le code source et les configurations sont disponibles dans le dépôt GitHub : kingabzpro/Gemini-2.5-Pro-Coding-App.

Conclusion

Il est désormais beaucoup plus facile de créer une application d'IA digne de ce nom. Au lieu de créer des applications complexes avec des outils comme LangChain, d'intégrer des magasins de vecteurs, d'optimiser les invites ou d'ajouter des chaînes de pensée, nous pouvons simplement initialiser le client Gemini 2.5 Pro via l'API de Google. L'API Gemini 2.5 Pro Chat peut traiter directement différents types de fichiers, permet de poser des questions complémentaires et fournit des réponses très précises.