Saltar al contenido principal

API Gemini 2.5 Pro: Una guía con proyecto de demostración

Aprende a utilizar la API Gemini 2.5 Pro para crear una aplicación web de análisis de código, aprovechando la gran ventana contextual del modelo.
Actualizado 28 mar 2025  · 12 min de lectura

¿Construir incluso una simple aplicación de IA no es un lío de almacenes de vectores, herramientas RAG, API y depuración? Ya no. Géminis 2.5 Pro viene con una larga ventana contextual de 1 millón de fichas (con planes de duplicarla) y la posibilidad de cargar archivos directamente sin necesidad de herramientas RAG o de almacén vectorial.

Gemini 2.5 Pro es un modelo de razonamiento que destaca en la codificación, y su enorme ventana contextual abre la puerta a un valor empresarial real en las aplicaciones centradas en el código. Por eso, en este blog, te guiaré en la construcción de una aplicación web adecuada que procese el código fuente y te ayude a optimizar tus proyectos de codificación en cuestión de segundos.

Voy a pasar directamente al código; si sólo buscas una visión general del modelo, consulta este blog de introducción sobre Géminis 2.5 Pro.

Desarrollar aplicaciones de IA

Aprende a crear aplicaciones de IA utilizando la API OpenAI.
Empieza a hacer Upskilling gratis

Conexión a la API de Gemini 2.5 Pro

Para acceder al modelo Gemini 2.5 Pro a través de la API de Google, sigue estos pasos:

1. Puesta en marcha

Primero, instala el paquete Python google-genai. Ejecuta el siguiente comando en tu terminal:

pip install google-genai

2. Generar una clave API

Ir a Google AI Studio y genera tu clave API. A continuación, establece la clave API como una variable de entorno en tu sistema.

google ai studio cómo crear una clave api

3. Crear el cliente GenAI

Utiliza la clave API para inicializar el cliente Google GenAI. Este cliente te permitirá interactuar con el 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. Carga el archivo

Carga el archivo Python con el que quieras trabajar y crea una consulta para el 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. Generar una respuesta

Crea una instancia de chat utilizando el modelo Gemini 2.5 Pro (gemini-2.5-pro-exp-03-25) y proporciónale el contenido del archivo y el prompt. El modelo analizará el código y generará una respuesta.

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 cuestión de segundos, se generó la respuesta consciente del contexto.

respuesta api con gemini 2.5 pro

Nota: El acceso gratuito al modelo puede no estar disponible actualmente debido a la elevada carga. Espera unos minutos y vuelve a intentarlo.

6. Ejecución del código (Experimental)

También puedes pedir al modelo que ejecute el código.

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

Ten en cuenta que esta función es experimental y tiene limitaciones. Por ejemplo, el modelo no puede ejecutar servidores web, acceder al sistema de archivos ni realizar operaciones de red.

respuesta API gemini 2.5 pro

Nota: El modelo Gemini 2.5 Pro incluye funciones avanzadas de "pensamiento". Aunque son visibles en Google AI Studio, no se incluyen en la salida de la API.

Crear una aplicación de análisis de código con Gemini 2.5 Pro

Esta aplicación permite a los usuarios subir archivos, incluidos varios archivos o incluso un archivo ZIP que contenga un proyecto entero, a una interfaz basada en chat. Los usuarios pueden hacer preguntas sobre su proyecto, solucionar problemas o mejorar su código base. A diferencia de los editores de código AI tradicionales, que tienen dificultades con contextos grandes debido a sus limitaciones, Gemini 2.5 Pro, con su larga ventana de contexto, puede analizar y resolver eficazmente los problemas de todo un proyecto.

1. Instalar las bibliotecas necesarias

Instala gradio para la creación de UI y zipfile36 para manejar archivos ZIP.

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

2. Configurar el cliente y la interfaz de usuario

Importa los paquetes Python necesarios, define variables globales, inicializa el cliente GenAI, configura constantes de interfaz de usuario y crea una lista de extensiones de archivo compatibles.

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. Función: extraer_texto_de_zip

La función extract_text_from_zip() extrae el contenido de texto de los ficheros de un archivo ZIP y lo devuelve como diccionario.

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. Función: extraer_texto_de_un_archivo

La función extract_text_from_single_file() extrae el contenido de texto de un único archivo y lo devuelve como diccionario.

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. Función: subir_zip

La función upload_zip() procesa los archivos subidos, ya sea en formato ZIP o archivos de texto, extrae el contenido del texto y añade un mensaje al 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. Función: usuario

La función user() añade el texto introducido por un usuario al historial de conversaciones del 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. Función: get_message_content

La función get_message_content() recupera el contenido de un mensaje, que puede ser un diccionario o un mensaje de chat de Gradio.

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

8. Función: send_to_gemini

La función send_to_gemini() envía la pregunta del usuario a Gemini AI y transmite la respuesta al chatbot. Si se subieran archivos de código, se incluirían en el 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. Función: reset_app

La función rest_app() reinicia la aplicación borrando el historial de chat y los archivos subidos.

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 de la interfaz de usuario de Gradio

Definamos los componentes de Gradio: chatbot, entrada de texto, botón de carga y botones de control.

# 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. Diseño de la app Gradio

Estructuremos la interfaz de Gradio utilizando filas y columnas para conseguir un diseño limpio.

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. Iniciar la aplicación

Vamos a lanzar la aplicación Gradio localmente con la cola activada para gestionar múltiples peticiones.

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

Prueba de la aplicación de análisis de código Gemini 2.5 Pro

Para lanzar la aplicación web, combina todas las fuentes de código anteriores en el archivo main.py (que he subido a GitHub para que te resulte más fácil copiarlo). Ejecútalo con el siguiente comando:

python main.py

La aplicación web estará disponible en la URL: http://localhost:9595/

Puedes copiar la URL y pegarla en tu navegador.

Como podemos ver, la aplicación web cuenta con una interfaz de chatbot. Podemos utilizarlo igual que ChatGPT.

proyecto de análisis de código gemini 2.5 pro

El botón "Subir" permite subir uno o varios archivos, así como archivos zip para tu proyecto. Así que no te preocupes si tu proyecto contiene más de 20 archivos; la aplicación de análisis de código podrá procesarlos y enviarlos a la API Gemini 2.5 Pro.

la app gemini 2.5 pro admite muchos tipos de entrada de archivos

Subamos varios archivos y pidamos a Gemini 2.5 Pro que mejore nuestro proyecto. 

Como vemos, el modelo proporciona sugerencias correctas de mejora.

proyecto gemini 2.5 pro con gradio

Podemos pedirle que aplique todas las sugerencias en el archivo secure_app.py.

Si quieres trabajar en otro proyecto, puedes hacer clic en el botón "Reiniciar" y empezar a charlar sobre el nuevo proyecto.

gemini 2.5 pro interfaz de chat con gradio

El código fuente y las configuraciones están disponibles en el repositorio de GitHub: kingabzpro/Gemini-2.5-Pro-Coding-App.

Conclusión

Crear una aplicación de IA adecuada es ahora mucho más fácil. En lugar de crear aplicaciones complejas con herramientas como LangChain, integrar almacenes vectoriales, optimizar avisos o añadir cadenas de pensamiento, podemos simplemente inicializar el cliente Gemini 2.5 Pro a través de la API de Google. La API del Chat Gemini 2.5 Pro puede manejar directamente varios tipos de archivos, permite preguntas de seguimiento y proporciona respuestas muy precisas.


Abid Ali Awan's photo
Author
Abid Ali Awan
LinkedIn
Twitter

Soy un científico de datos certificado que disfruta creando aplicaciones de aprendizaje automático y escribiendo blogs sobre ciencia de datos. Actualmente me centro en la creación de contenidos, la edición y el trabajo con grandes modelos lingüísticos.

Temas

Aprende IA con estos cursos

Programa

Developing AI Applications

0 min
Learn to create AI-powered applications with the latest AI developer tools, including the OpenAI API, Hugging Face, and LangChain.
Ver detallesRight Arrow
Comienza el curso
Ver másRight Arrow
Relacionado
An AI juggles tasks

blog

Cinco proyectos que puedes crear con modelos de IA generativa (con ejemplos)

Aprende a utilizar modelos de IA generativa para crear un editor de imágenes, un chatbot similar a ChatGPT con pocos recursos y una aplicación clasificadora de aprobación de préstamos y a automatizar interacciones PDF y un asistente de voz con GPT.
Abid Ali Awan's photo

Abid Ali Awan

10 min

Tutorial

Tutorial de DeepSeek-Coder-V2: Ejemplos, instalación, puntos de referencia

DeepSeek-Coder-V2 es un modelo de lenguaje de código de código abierto que rivaliza con el rendimiento de GPT-4, Gemini 1.5 Pro, Claude 3 Opus, Llama 3 70B o Codestral.
Dimitri Didmanidze's photo

Dimitri Didmanidze

8 min

Tutorial

Tutorial sobre cómo crear aplicaciones LLM con LangChain

Explore el potencial sin explotar de los grandes modelos lingüísticos con LangChain, un marco Python de código abierto para crear aplicaciones avanzadas de IA.
Moez Ali's photo

Moez Ali

12 min

Tutorial

Guía para principiantes de la API de OpenAI: Tutorial práctico y prácticas recomendadas

Este tutorial te presenta la API de OpenAI, sus casos de uso, un enfoque práctico para utilizar la API y todas las prácticas recomendadas que debes seguir.
Arunn Thevapalan's photo

Arunn Thevapalan

13 min

Tutorial

Tutorial de la API de OpenAI Assistants

Una visión completa de la API Assistants con nuestro artículo, que ofrece una mirada en profundidad a sus características, usos en la industria, guía de configuración y las mejores prácticas para maximizar su potencial en diversas aplicaciones empresariales.
Zoumana Keita 's photo

Zoumana Keita

14 min

Tutorial

Ajuste fino de LLaMA 2: Guía paso a paso para personalizar el modelo de lenguaje grande

Aprende a ajustar Llama-2 en Colab utilizando nuevas técnicas para superar las limitaciones de memoria y computación y hacer más accesibles los grandes modelos lingüísticos de código abierto.
Abid Ali Awan's photo

Abid Ali Awan

12 min

Ver másVer más