API do Gemini 2.5 Pro: Um guia com projeto de demonstração

Conectando-se à API do Gemini 2.5 Pro

Para acessar o modelo Gemini 2.5 Pro por meio da API do Google, siga estas etapas:

1. Configuração

Primeiro, instale o pacote google-genai Python. Execute o seguinte comando em seu terminal:

pip install google-genai

2. Geração de uma chave de API

Ir para Google AI Studio e gere sua chave de API. Em seguida, defina a chave da API como uma variável de ambiente variável de ambiente em seu sistema.

3. Criar o cliente GenAI

Use a chave da API para inicializar o cliente do Google GenAI. Esse cliente permitirá que você interaja com o modelo 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. Carregar o arquivo

Carregue o arquivo Python com o qual você deseja trabalhar e crie um prompt para o modelo.

# 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. Gerar uma resposta

Crie uma instância de bate-papo usando o modelo Gemini 2.5 Pro (gemini-2.5-pro-exp-03-25) e forneça a ela o conteúdo do arquivo e o prompt. O modelo analisará o código e gerará uma resposta.

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)

Em segundos, a resposta com reconhecimento de contexto foi gerada.

Observação: O acesso gratuito ao modelo pode não estar disponível no momento devido à alta carga. Aguarde alguns minutos e tente novamente.

6. Execução de código (Experimental)

Você também pode solicitar ao modelo que execute o código.

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

Observe que esse recurso é experimental e tem limitações. Por exemplo, o modelo não pode executar servidores da Web, acessar o sistema de arquivos ou realizar operações de rede.

Observação: O modelo Gemini 2.5 Pro inclui recursos avançados de "raciocínio". Embora sejam visíveis no Google AI Studio, eles não estão incluídos na saída da API.

Criando um aplicativo de análise de código com o Gemini 2.5 Pro

Esse aplicativo permite que os usuários façam upload de arquivos, incluindo vários arquivos ou até mesmo um arquivo ZIP contendo um projeto inteiro, para uma interface baseada em bate-papo. Os usuários podem fazer perguntas sobre seus projetos, solucionar problemas ou melhorar sua base de código. Ao contrário dos editores de código de IA tradicionais, que têm dificuldades com contextos grandes devido às suas limitações, o Gemini 2.5 Pro, com sua longa janela de contexto, pode analisar e resolver problemas de forma eficaz em um projeto inteiro.

1. Instalando as bibliotecas necessárias

Instale gradio para a criação da interface do usuário e zipfile36 para lidar com arquivos ZIP.

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

2. Configuração do cliente e da interface do usuário

Importe os pacotes Python necessários, defina as variáveis globais, inicialize o cliente GenAI, configure as constantes da interface do usuário e crie uma lista de extensões de arquivo compatíveis.

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. Função: extract_text_from_zip

A função extract_text_from_zip() extrai o conteúdo de texto dos arquivos dentro de um arquivo ZIP e o retorna como um dicionário.

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. Function: extract_text_from_single_file

A função extract_text_from_single_file() extrai o conteúdo de texto de um único arquivo e o retorna como um dicionário.

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. Função: upload_zip

A função upload_zip() processa os arquivos carregados, seja no formato ZIP ou em arquivos de texto, extrai o conteúdo do texto e anexa uma mensagem ao bate-papo.

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. Função: usuário

A função user() anexa a entrada de texto de um usuário ao histórico de conversas do 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. Função: get_message_content

A função get_message_content() recupera o conteúdo de uma mensagem, que pode ser um dicionário ou uma mensagem de bate-papo do Gradio.

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

8. Função: send_to_gemini

A função send_to_gemini() envia o prompt do usuário para a Gemini AI e transmite a resposta de volta para o chatbot. Se os arquivos de código forem carregados, eles serão incluídos no contexto.

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. Função: reset_app

A função rest_app() redefine o aplicativo, limpando o histórico de bate-papo e todos os arquivos carregados.

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. Componentes da interface do usuário do Gradio

Vamos definir os componentes do Gradio: chatbot, entrada de texto, botão de upload e botões de controle.

# 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. Layout do aplicativo Gradio

Vamos estruturar a interface do Gradio usando linhas e colunas para que você tenha um layout limpo.

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. Iniciando o aplicativo

Vamos iniciar o aplicativo Gradio localmente com o enfileiramento ativado para lidar com várias solicitações.

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

Testando o aplicativo de análise de código Gemini 2.5 Pro

Para iniciar o aplicativo da Web, combine todas as fontes de código acima no arquivo main.py (que carreguei no GitHub para facilitar a cópia para você). Execute-o com o seguinte comando:

python main.py

O aplicativo da Web estará disponível no URL: http://localhost:9595/

Você pode copiar o URL e colá-lo no navegador da Web.

Como podemos ver, o aplicativo da Web apresenta uma interface de chatbot. Você pode usá-lo da mesma forma que o ChatGPT.

O botão "Upload" suporta uploads de arquivos únicos e múltiplos, bem como arquivos zip para o seu projeto. Portanto, não se preocupe se o seu projeto contiver mais de 20 arquivos; o aplicativo de análise de código será capaz de processá-los e enviá-los para a API Gemini 2.5 Pro.

Vamos carregar vários arquivos e pedir ao Gemini 2.5 Pro que aprimore o nosso projeto. 

Como podemos ver, o modelo fornece sugestões corretas de aprimoramentos.

Podemos solicitar que ele implemente todas as sugestões no arquivo secure_app.py.

Se quiser trabalhar em outro projeto, você pode clicar no botão "Reset" e começar a conversar sobre o novo projeto.

O código-fonte e as configurações estão disponíveis no repositório do GitHub: kingabzpro/Gemini-2.5-Pro-Coding-App.

Conclusão

Criar um aplicativo de IA adequado ficou muito mais fácil. Em vez de criar aplicativos complexos com ferramentas como LangChain, integrar lojas de vetores, otimizar prompts ou adicionar cadeias de pensamento, podemos simplesmente inicializar o cliente Gemini 2.5 Pro por meio da API do Google. A API do Gemini 2.5 Pro Chat pode lidar diretamente com vários tipos de arquivos, permite perguntas de acompanhamento e fornece respostas altamente precisas.