Tutorial Gemini 3.1 Pro: Como Usar la API de Google AI Studio Paso a Paso [2026]

Tutorial Gemini 3.1 Pro: Como Usar la API de Google AI Studio Paso a Paso [2026]

Gemini 3.1 Pro de Google es uno de los modelos de IA mas potentes disponibles en marzo de 2026, y su API es una de las mas generosas del mercado: 1 millon de tokens de contexto, capacidades multimodales nativas y un tier gratuito que permite hasta 60 peticiones por minuto sin pagar. En este tutorial te enseno a configurarlo todo desde cero, con ejemplos de codigo en Python que puedes copiar y ejecutar directamente.

¿Quieres dominar la IA? En La Escuela de IA compartimos tutoriales y recursos. Unete gratis. Tambien en YouTube @JavadexAI.

TL;DR

• Gemini 3.1 Pro ofrece 1M de tokens de contexto, multimodal nativo y un tier gratuito generoso.
• Necesitas una API key de Google AI Studio (gratis, se obtiene en 2 minutos).
• El SDK oficial de Python es google-generativeai -- instalable con pip.
• Soporta texto, imagenes, audio y video en una sola llamada a la API.
• Function calling permite conectar Gemini a tus propias herramientas y APIs.
• Streaming reduce la latencia percibida para aplicaciones interactivas.
• Para produccion empresarial, usa Vertex AI en lugar de AI Studio.

Requisitos Previos

Antes de empezar, asegurate de tener:

• Python 3.9 o superior instalado
• Una cuenta de Google (cualquier cuenta Gmail sirve)
• pip actualizado (pip install --upgrade pip)
• Un editor de codigo (VS Code, Cursor, o similar)

No necesitas tarjeta de credito para el tier gratuito.

Paso 1: Obtener tu API Key de Google AI Studio

1. Ve a Google AI Studio
2. Inicia sesion con tu cuenta de Google
3. Haz clic en "Get API Key" en el menu lateral
4. Selecciona "Create API key"
5. Elige un proyecto de Google Cloud existente o crea uno nuevo
6. Copia la clave generada y guardala en un lugar seguro

Tu API key tendra un formato similar a: AIzaSyD... (39 caracteres).

Importante: Nunca compartas tu API key ni la incluyas directamente en el codigo fuente. Usa variables de entorno:

1export GOOGLE_API_KEY="tu-api-key-aqui"

Paso 2: Instalar el SDK de Python

Instala la libreria oficial de Google:

1pip install google-generativeai

Para un entorno mas completo con todas las dependencias opcionales:

1pip install google-generativeai Pillow requests

Verifica la instalacion:

1import google.generativeai as genai
2print(genai.__version__)

Deberias ver una version 0.8.x o superior.

Paso 3: Tu Primera Llamada a la API

Este es el ejemplo mas basico -- enviar un prompt de texto y recibir una respuesta:

1import google.generativeai as genai
2import os
3 
4# Configurar la API key
5genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
6 
7# Crear instancia del modelo
8model = genai.GenerativeModel("gemini-1.5-pro-latest")
9 
10# Generar una respuesta
11response = model.generate_content("Explica que es un transformer en IA en 3 parrafos.")
12 
13print(response.text)

Si todo funciona correctamente, veras una explicacion clara y estructurada sobre la arquitectura Transformer.

Parametros de Generacion

Puedes controlar el comportamiento del modelo con parametros adicionales:

1from google.generativeai.types import GenerationConfig
2 
3config = GenerationConfig(
4    temperature=0.7,        # 0.0 = determinista, 2.0 = muy creativo
5    top_p=0.95,             # Nucleus sampling
6    top_k=40,               # Top-K sampling
7    max_output_tokens=2048, # Limite de tokens de salida
8    candidate_count=1       # Numero de respuestas alternativas
9)
10 
11response = model.generate_content(
12    "Escribe un poema sobre inteligencia artificial.",
13    generation_config=config
14)

Paso 4: System Instructions (Instrucciones del Sistema)

Las instrucciones del sistema definen el comportamiento base del modelo. Se configuran al crear la instancia:

1model = genai.GenerativeModel(
2    model_name="gemini-1.5-pro-latest",
3    system_instruction="""Eres un experto en inteligencia artificial que trabaja
4    como consultor para empresas espanolas. Respondes siempre en espanol de Espana,
5    usando un tono profesional pero accesible. Cuando no sepas algo, lo reconoces
6    abiertamente. Citas fuentes cuando es posible."""
7)
8 
9response = model.generate_content("¿Cual es el estado actual de la IA en Espana?")
10print(response.text)

Las instrucciones del sistema se envian con cada peticion pero no cuentan como parte del historial de conversacion. Son ideales para definir el tono, idioma, formato de respuesta y restricciones del modelo.

Paso 5: Multimodal -- Enviar Imagenes con Texto

Una de las grandes ventajas de Gemini es su capacidad multimodal nativa. Puedes enviar imagenes junto con texto sin necesidad de un modelo separado.

Imagen desde archivo local

1import PIL.Image
2 
3# Cargar una imagen local
4img = PIL.Image.open("captura-dashboard.png")
5 
6# Enviar imagen + texto al modelo
7response = model.generate_content([
8    "Analiza esta captura de pantalla de un dashboard. Describe los datos que ves y sugiere mejoras de UX.",
9    img
10])
11 
12print(response.text)

Imagen desde URL

1import requests
2from PIL import Image
3from io import BytesIO
4 
5# Descargar imagen desde URL
6url = "https://example.com/imagen.jpg"
7response_img = requests.get(url)
8img = Image.open(BytesIO(response_img.content))
9 
10# Analizar con Gemini
11response = model.generate_content([
12    "Describe detalladamente lo que ves en esta imagen.",
13    img
14])

Multiples Imagenes

Gemini puede procesar varias imagenes en una sola peticion:

1img1 = PIL.Image.open("diseno-v1.png")
2img2 = PIL.Image.open("diseno-v2.png")
3 
4response = model.generate_content([
5    "Compara estos dos disenos de interfaz. ¿Cual es mas intuitivo y por que?",
6    img1,
7    img2
8])

Paso 6: Aprovechar el Contexto de 1 Millon de Tokens

El contexto de 1 millon de tokens es la ventaja competitiva de Gemini sobre OpenAI y Anthropic. Esto equivale a aproximadamente 700.000 palabras o varios libros completos en una sola peticion.

Caso de uso: Analisis de documentos largos

1# Cargar un documento largo
2with open("informe-anual-2025.txt", "r") as f:
3    documento = f.read()
4 
5print(f"Longitud del documento: {len(documento)} caracteres")
6 
7response = model.generate_content(f"""
8Analiza el siguiente informe anual y genera:
91. Un resumen ejecutivo de 500 palabras
102. Los 5 puntos clave mas importantes
113. Riesgos identificados
124. Recomendaciones de accion
13 
14DOCUMENTO:
15{documento}
16""")
17 
18print(response.text)

Caso de uso: Analisis de codigo completo

1import os
2 
3# Leer todos los archivos Python de un proyecto
4codigo_proyecto = ""
5for root, dirs, files in os.walk("./mi-proyecto"):
6    for file in files:
7        if file.endswith(".py"):
8            filepath = os.path.join(root, file)
9            with open(filepath, "r") as f:
10                codigo_proyecto += f"\n\n# --- {filepath} ---\n\n"
11                codigo_proyecto += f.read()
12 
13response = model.generate_content(f"""
14Revisa el siguiente proyecto Python completo. Identifica:
151. Bugs potenciales
162. Problemas de seguridad
173. Oportunidades de refactorizacion
184. Mejoras de rendimiento
19 
20CODIGO:
21{codigo_proyecto}
22""")

Consejo: Aunque puedes enviar hasta 1M de tokens, el rendimiento del modelo disminuye ligeramente con contextos muy largos. Para la mayoria de aplicaciones, 100K-200K tokens son mas que suficientes. Si trabajas con documentos extremadamente largos, considera implementar RAG para seleccionar los fragmentos mas relevantes.

Paso 7: Streaming para Respuestas en Tiempo Real

El streaming es esencial para aplicaciones interactivas como chatbots. En lugar de esperar a que el modelo genere la respuesta completa, recibes tokens a medida que se generan:

1response = model.generate_content(
2    "Escribe una guia detallada sobre como empezar con machine learning.",
3    stream=True
4)
5 
6for chunk in response:
7    print(chunk.text, end="", flush=True)
8 
9print()  # Salto de linea al final

Streaming con conversacion

1chat = model.start_chat(history=[])
2 
3response = chat.send_message(
4    "Explicame los tipos de redes neuronales que existen.",
5    stream=True
6)
7 
8for chunk in response:
9    print(chunk.text, end="", flush=True)

La latencia hasta el primer token con streaming suele ser de 200-500 milisegundos, haciendo que la experiencia de usuario sea mucho mas fluida que esperar 5-10 segundos por una respuesta completa.

Paso 8: Function Calling (Llamada a Funciones)

Function calling permite que Gemini llame a funciones que tu defines, conectando el modelo con tus propias APIs y herramientas. Es la base para construir agentes de IA.

Definir funciones

1def obtener_tiempo(ciudad: str) -> dict:
2    """Obtiene el tiempo actual en una ciudad."""
3    # En produccion, llamarias a una API real
4    datos_simulados = {
5        "Madrid": {"temp": 18, "condicion": "Soleado"},
6        "Barcelona": {"temp": 16, "condicion": "Nublado"},
7        "Vigo": {"temp": 14, "condicion": "Lluvioso"},
8    }
9    return datos_simulados.get(ciudad, {"temp": "desconocido", "condicion": "desconocido"})
10 
11def buscar_restaurantes(ciudad: str, tipo_cocina: str) -> list:
12    """Busca restaurantes en una ciudad por tipo de cocina."""
13    return [
14        {"nombre": f"Restaurante {tipo_cocina} 1", "rating": 4.5},
15        {"nombre": f"Restaurante {tipo_cocina} 2", "rating": 4.2},
16    ]

Configurar el modelo con herramientas

1model = genai.GenerativeModel(
2    model_name="gemini-1.5-pro-latest",
3    tools=[obtener_tiempo, buscar_restaurantes]
4)
5 
6chat = model.start_chat()
7 
8response = chat.send_message(
9    "¿Que tiempo hace en Vigo? Y recomiendame un restaurante de marisco alli."
10)
11 
12# Gemini puede llamar a ambas funciones automaticamente
13print(response.text)

Flujo de function calling

1. Envias el mensaje del usuario
2. Gemini decide si necesita llamar a una funcion
3. Si lo hace, devuelve un function_call con los argumentos
4. Tu ejecutas la funcion y devuelves el resultado
5. Gemini genera la respuesta final usando los datos reales

Este mecanismo es fundamental para construir aplicaciones de IA que interactuen con el mundo real: consultar bases de datos, llamar a APIs externas, ejecutar operaciones CRUD, etc.

Paso 9: Safety Settings (Configuracion de Seguridad)

Gemini incluye filtros de seguridad que pueden bloquear contenido que considere danino. Puedes ajustar estos filtros segun tu caso de uso:

1from google.generativeai.types import HarmCategory, HarmBlockThreshold
2 
3model = genai.GenerativeModel(
4    model_name="gemini-1.5-pro-latest",
5    safety_settings={
6        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
7        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
8        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
9        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
10    }
11)

Paso 10: Conversaciones con Historial

Para crear chatbots con memoria de la conversacion:

1model = genai.GenerativeModel("gemini-1.5-pro-latest")
2 
3chat = model.start_chat(history=[])
4 
5# Primera pregunta
6r1 = chat.send_message("Me llamo Javier y trabajo como consultor de IA en Vigo.")
7print(f"Gemini: {r1.text}\n")
8 
9# Segunda pregunta (el modelo recuerda el contexto)
10r2 = chat.send_message("¿Que herramientas de IA me recomiendas para mi trabajo?")
11print(f"Gemini: {r2.text}\n")
12 
13# Tercera pregunta
14r3 = chat.send_message("¿Y para automatizar tareas repetitivas?")
15print(f"Gemini: {r3.text}\n")
16 
17# Ver el historial completo
18for msg in chat.history:
19    print(f"[{msg.role}]: {msg.parts[0].text[:100]}...")

El historial se mantiene en memoria y se envia con cada peticion. Esto consume tokens de entrada, asi que ten en cuenta el coste si las conversaciones son largas.

Google AI Studio vs Vertex AI: ¿Cual Elegir?

Ganador para produccion empresarial: Vertex AI - SLA del 99.9%, seguridad enterprise con VPC e IAM, y escalado automatico para aplicaciones con trafico real.

Mi recomendacion: Usa AI Studio para desarrollar y prototipar. Cuando tu aplicacion tenga trafico real y necesites SLAs, migra a Vertex AI. La API es practicamente identica, solo cambia la autenticacion.

Para Quien Es Este Tutorial

• ✅ Desarrolladores Python que quieren integrar un modelo de IA de frontera en sus aplicaciones sin gastar dinero
• ✅ Equipos que necesitan procesar documentos largos (contratos, informes, libros) con hasta 1 millon de tokens de contexto
• ✅ Startups en fase de prototipado que buscan una API multimodal potente con tier gratuito generoso
• ✅ Programadores que ya usan OpenAI o Anthropic y quieren explorar Gemini como alternativa mas economica
• ✅ Creadores de chatbots o agentes de IA que necesitan function calling y streaming
• ❌ No ideal si necesitas el mejor rendimiento absoluto en generacion de codigo -- Claude Opus 4.6 sigue siendo superior en ese aspecto
• ❌ No recomendado para produccion enterprise critica sin migrar a Vertex AI con SLAs garantizados
• ❌ No es la mejor opcion si necesitas Computer Use o control de escritorio -- esa capacidad la lidera Claude

Ganador en coste de procesamiento de documentos largos: Gemini 3.1 Pro - Procesar un libro completo de 100K tokens cuesta 12 centimos con Gemini vs mas de 50 centimos con GPT-5.2 o Claude, y ademas tiene tier gratuito.

Ejemplo Completo: Asistente de Analisis de Documentos

Este ejemplo combina todo lo aprendido en un asistente funcional:

1import google.generativeai as genai
2import os
3 
4genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
5 
6model = genai.GenerativeModel(
7    model_name="gemini-1.5-pro-latest",
8    system_instruction="""Eres un analista de documentos experto. Tu trabajo es:
9    1. Resumir documentos de forma clara y estructurada
10    2. Identificar puntos clave y datos relevantes
11    3. Responder preguntas sobre el contenido
12    4. Sugerir acciones basadas en el analisis
13    Responde siempre en espanol de Espana."""
14)
15 
16def analizar_documento(ruta_archivo: str):
17    """Analiza un documento y permite hacer preguntas sobre el."""
18 
19    with open(ruta_archivo, "r", encoding="utf-8") as f:
20        contenido = f.read()
21 
22    chat = model.start_chat(history=[])
23 
24    # Primer mensaje: cargar el documento
25    respuesta = chat.send_message(f"""
26    He cargado el siguiente documento para analisis:
27 
28    ---
29    {contenido}
30    ---
31 
32    Por favor, genera:
33    1. Resumen ejecutivo (200 palabras)
34    2. 5 puntos clave
35    3. Datos numericos mas relevantes
36    """)
37 
38    print("=== ANALISIS INICIAL ===")
39    print(respuesta.text)
40 
41    # Permitir preguntas interactivas
42    while True:
43        pregunta = input("\nPregunta sobre el documento (o 'salir'): ")
44        if pregunta.lower() == "salir":
45            break
46 
47        respuesta = chat.send_message(pregunta, stream=True)
48        print("\nRespuesta: ", end="")
49        for chunk in respuesta:
50            print(chunk.text, end="", flush=True)
51        print()
52 
53# Uso
54analizar_documento("informe-trimestral.txt")

Paso 11: Embeddings para Busqueda Semantica

Gemini 3.1 Pro tambien ofrece un modelo de embeddings que puedes usar para busqueda semantica, clasificacion y clustering de textos. Esto es fundamental si quieres construir sistemas de RAG.

1# Generar embeddings para busqueda semantica
2result = genai.embed_content(
3    model="models/text-embedding-004",
4    content="¿Como funciona la atencion en transformers?",
5    task_type="retrieval_query"
6)
7 
8print(f"Dimensiones del embedding: {len(result['embedding'])}")
9print(f"Primeros 5 valores: {result['embedding'][:5]}")
10 
11# Generar embeddings para documentos (base de conocimiento)
12documentos = [
13    "La atencion multi-cabeza permite al modelo enfocarse en diferentes partes del input.",
14    "Los transformers usan codificacion posicional para entender el orden de las palabras.",
15    "BERT fue el primer modelo preentrenado basado en transformers para NLP.",
16]
17 
18doc_embeddings = genai.embed_content(
19    model="models/text-embedding-004",
20    content=documentos,
21    task_type="retrieval_document"
22)
23 
24print(f"Embeddings generados: {len(doc_embeddings['embedding'])}")

Construir una busqueda semantica basica

1import numpy as np
2 
3def cosine_similarity(a, b):
4    """Calcula la similitud coseno entre dos vectores."""
5    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
6 
7def buscar(query: str, documentos: list, doc_embeddings: list) -> list:
8    """Busca los documentos mas relevantes para una query."""
9    # Generar embedding de la query
10    query_result = genai.embed_content(
11        model="models/text-embedding-004",
12        content=query,
13        task_type="retrieval_query"
14    )
15    query_emb = query_result['embedding']
16 
17    # Calcular similitud con cada documento
18    resultados = []
19    for i, doc_emb in enumerate(doc_embeddings):
20        score = cosine_similarity(query_emb, doc_emb)
21        resultados.append((score, documentos[i]))
22 
23    # Ordenar por relevancia (mayor similitud primero)
24    resultados.sort(reverse=True, key=lambda x: x[0])
25    return resultados
26 
27# Ejemplo de uso
28resultados = buscar(
29    "¿que es la atencion en redes neuronales?",
30    documentos,
31    doc_embeddings['embedding']
32)
33 
34for score, doc in resultados:
35    print(f"[{score:.3f}] {doc}")

Este patron es la base de sistemas RAG mas complejos. Si quieres profundizar, tenemos un tutorial completo de RAG.

Paso 12: Procesar Video con Gemini

Una capacidad exclusiva de Gemini es el procesamiento nativo de video. Puedes subir un video y hacer preguntas sobre su contenido:

1import time
2 
3# Subir un archivo de video
4video_file = genai.upload_file("demo-producto.mp4")
5 
6# Esperar a que se procese
7while video_file.state.name == "PROCESSING":
8    print("Procesando video...")
9    time.sleep(5)
10    video_file = genai.get_file(video_file.name)
11 
12print(f"Video procesado: {video_file.uri}")
13 
14# Hacer preguntas sobre el video
15response = model.generate_content([
16    video_file,
17    "Analiza este video de demo de producto. Resume las funcionalidades mostradas, "
18    "identifica posibles mejoras de UX y genera un guion alternativo de 2 minutos."
19])
20 
21print(response.text)

Analisis de multiples frames

1# Puedes especificar timestamps para analizar momentos concretos
2response = model.generate_content([
3    video_file,
4    "En los primeros 30 segundos, ¿que accion realiza el usuario? "
5    "¿La interfaz responde de forma fluida o hay algun retraso visible?"
6])

Esta capacidad es especialmente util para equipos de QA que necesitan analizar demos de producto, grabaciones de sesiones de usuario o videos de formacion.

Errores Comunes al Usar la API de Gemini (y Como Solucionarlos)

Despues de integrar la API de Gemini en varios proyectos reales, he recopilado los errores mas frecuentes. Esta seccion te ahorrara horas de debugging.

1. Error 429: Rate Limit Exceeded

Causa: Has superado el limite de peticiones por minuto (60 RPM en tier gratuito).

Solucion:

1import time
2from google.api_core.exceptions import ResourceExhausted
3 
4def llamar_con_retry(model, prompt, max_retries=3):
5    """Llama a la API con reintentos automaticos ante rate limiting."""
6    for intento in range(max_retries):
7        try:
8            return model.generate_content(prompt)
9        except ResourceExhausted:
10            espera = 2 ** intento  # Backoff exponencial: 1, 2, 4 segundos
11            print(f"Rate limit alcanzado. Esperando {espera}s...")
12            time.sleep(espera)
13    raise Exception("Rate limit persistente despues de reintentos")

2. Safety Filter bloquea respuestas legitimas

Causa: los filtros de seguridad son demasiado agresivos para tu caso de uso (comun en aplicaciones educativas o de salud).

Solucion: ajusta los safety settings como se muestra en el Paso 9, pero documenta siempre las razones del cambio. Nunca desactives filtros en produccion sin una revision de seguridad.

3. Respuestas truncadas por max_output_tokens

Causa: el limite de tokens de salida es demasiado bajo para la respuesta que el modelo necesita generar.

Solucion:

1# Aumentar el limite de tokens de salida
2config = GenerationConfig(max_output_tokens=8192)  # Maximo permitido
3 
4# Alternativa: dividir la tarea en partes
5response1 = model.generate_content("Escribe la primera mitad del informe...")
6response2 = model.generate_content("Continua con la segunda mitad...")

4. Costes inesperados por historial de conversacion acumulado

Causa: en una conversacion larga, cada mensaje envia todo el historial previo como tokens de entrada, lo que incrementa el coste exponencialmente.

Solucion: implementa una estrategia de gestion de historial:

1def limpiar_historial(chat, max_mensajes=20):
2    """Mantiene solo los ultimos N mensajes para controlar costes."""
3    if len(chat.history) > max_mensajes * 2:  # *2 porque hay user + model
4        # Guardar solo los mensajes recientes
5        chat._history = chat.history[-(max_mensajes * 2):]
6    return chat

5. No usar prompt caching para system prompts largos

Causa: enviar el mismo system prompt de 5.000+ tokens en cada peticion sin aprovechar el caching.

Solucion: utiliza cached_content para almacenar prompts que se repiten frecuentemente. Esto reduce el coste de tokens de entrada hasta un 90% en llamadas repetitivas.

Integracion con Otras Herramientas y Servicios

Gemini 3.1 Pro no vive aislado. Aqui te muestro como integrarlo con las herramientas mas populares del ecosistema de desarrollo.

Integracion con LangChain

LangChain es el framework mas popular para construir aplicaciones con LLMs. La integracion con Gemini es nativa:

1from langchain_google_genai import ChatGoogleGenerativeAI
2from langchain_core.messages import HumanMessage, SystemMessage
3 
4# Crear instancia del modelo via LangChain
5llm = ChatGoogleGenerativeAI(
6    model="gemini-1.5-pro-latest",
7    google_api_key=os.environ["GOOGLE_API_KEY"],
8    temperature=0.3
9)
10 
11# Usar con mensajes de LangChain
12messages = [
13    SystemMessage(content="Eres un experto en analisis de datos."),
14    HumanMessage(content="Analiza las tendencias de ventas del Q1 2026.")
15]
16 
17response = llm.invoke(messages)
18print(response.content)

Integracion con n8n para automatizacion

Si usas n8n para automatizacion sin codigo, puedes conectar Gemini 3.1 Pro a tus workflows:

1. Anade un nodo HTTP Request en n8n.
2. Configura el endpoint: https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro-latest:generateContent.
3. Anade tu API key como header de autorizacion.
4. Envia el prompt como body JSON.

Esto permite integrar Gemini en flujos de trabajo como: recibir email con documento adjunto, procesarlo con Gemini y enviar un resumen por Slack.

Integracion con bases de datos vectoriales

Para construir sistemas RAG completos, combina los embeddings de Gemini con una base de datos vectorial:

1import chromadb
2 
3# Crear coleccion en ChromaDB
4client = chromadb.Client()
5collection = client.create_collection("documentos")
6 
7# Indexar documentos con embeddings de Gemini
8for i, doc in enumerate(documentos):
9    embedding = genai.embed_content(
10        model="models/text-embedding-004",
11        content=doc,
12        task_type="retrieval_document"
13    )
14    collection.add(
15        embeddings=[embedding['embedding']],
16        documents=[doc],
17        ids=[f"doc_{i}"]
18    )
19 
20# Buscar documentos relevantes
21query_emb = genai.embed_content(
22    model="models/text-embedding-004",
23    content="¿Que es la atencion en transformers?",
24    task_type="retrieval_query"
25)
26 
27results = collection.query(
28    query_embeddings=[query_emb['embedding']],
29    n_results=3
30)
31 
32print("Documentos mas relevantes:", results['documents'])

Integracion con FastAPI para crear un servicio web

Si necesitas exponer Gemini como una API propia, FastAPI es la opcion mas rapida:

1from fastapi import FastAPI
2from pydantic import BaseModel
3 
4app = FastAPI()
5 
6class Consulta(BaseModel):
7    pregunta: str
8    contexto: str = ""
9 
10@app.post("/analizar")
11async def analizar(consulta: Consulta):
12    prompt = f"{consulta.contexto}\n\nPregunta: {consulta.pregunta}"
13    response = model.generate_content(prompt)
14    return {"respuesta": response.text}
15 
16# Ejecutar con: uvicorn app:app --host 0.0.0.0 --port 8000

Esto te permite crear microservicios que usan Gemini como backend, integrables con cualquier aplicacion web o movil.

Articulos Relacionados

• Gemini 3.1 Pro: Analisis Completo y Benchmarks
• Mejores APIs IA: Precios y Comparativa
• Google AI Studio: Tutorial en Espanol (Feb)
• Gemini 3.1 Pro: Analisis Febrero

Mi Recomendacion Personal

He usado la API de Gemini 3.1 Pro en varios proyectos reales y puedo decir que es la API con mejor relacion funcionalidad-precio del mercado en marzo de 2026. Su contexto de 1 millon de tokens cambia completamente lo que es posible hacer con una sola llamada a la API.

1. Google AI Studio con tier gratuito para prototipos, proyectos personales y experimentacion -- cubre el 80% de las necesidades sin gastar un euro
2. Gemini 3.1 Pro de pago para aplicaciones en produccion que procesan documentos largos o video, donde el coste de 1.25/5 dolares por millon de tokens es muy competitivo
3. Vertex AI cuando tu aplicacion necesita SLAs enterprise, escalado automatico y seguridad avanzada con VPC e IAM

Para la mayoria de desarrolladores, recomiendo empezar con AI Studio hoy mismo -- la configuracion lleva 2 minutos, el SDK de Python es limpio y el tier gratuito te permite hacer 60 peticiones por minuto sin pagar. Es la forma mas rapida de empezar a construir con un modelo de IA de frontera.

Preguntas Frecuentes

¿Gemini 3.1 Pro es realmente gratis?

Si, el tier gratuito de Google AI Studio permite usar Gemini 3.1 Pro sin coste con un limite de 60 peticiones por minuto y 1.500 peticiones diarias. Para la mayoria de proyectos personales y prototipos, esto es mas que suficiente. Si necesitas mas, los precios empiezan en 1.25 dolares por millon de tokens de entrada.

¿Puedo usar Gemini 3.1 Pro para una aplicacion comercial?

Si. Tanto el tier gratuito como el de pago permiten uso comercial. Sin embargo, para aplicaciones en produccion con usuarios reales, recomiendo usar Vertex AI en lugar de AI Studio para tener SLAs de disponibilidad y soporte empresarial.

¿Como se compara Gemini 3.1 Pro con GPT-5.2 y Claude Opus 4.6?

Gemini 3.1 Pro destaca en contexto largo (1M tokens vs 200K) y en capacidades multimodales (incluyendo video). GPT-5.2 es superior en tareas generales y tiene mejor ecosistema. Claude Opus 4.6 lidera en programacion y razonamiento. Para una comparativa detallada de precios, consulta nuestro articulo dedicado.

¿Funciona Gemini con idioma espanol?

Si, Gemini 3.1 Pro tiene un excelente soporte para espanol. Tanto la generacion de texto como la comprension multimodal funcionan correctamente en espanol. Las system instructions en espanol son respetadas de forma consistente.

¿Cuanto cuesta procesar un libro completo con Gemini?

Un libro tipico de 300 paginas tiene aproximadamente 100.000 tokens. Con el tier gratuito, puedes procesarlo sin coste. Con el tier de pago, el coste de entrada seria de unos 0.125 dolares (12 centimos) para los 100K tokens de entrada mas el coste del output. Es significativamente mas barato que cualquier alternativa con ventanas de contexto similares.

Conclusion

Gemini 3.1 Pro es probablemente la API de IA con mejor relacion funcionalidad-precio del mercado en marzo de 2026. Su combinacion de contexto de 1 millon de tokens, capacidades multimodales nativas, function calling robusto y un tier gratuito generoso la convierten en una opcion excelente tanto para prototipos como para aplicaciones en produccion.

Los pasos para empezar son simples:

1. Crea una API key en Google AI Studio (2 minutos)
2. Instala el SDK de Python (pip install google-generativeai)
3. Empieza con el ejemplo basico de generacion de texto
4. Explora multimodal, streaming y function calling
5. Cuando necesites produccion empresarial, migra a Vertex AI

La barrera de entrada nunca ha sido tan baja para trabajar con un modelo de IA de frontera.

¿Quieres ver mas tutoriales como este? En La Escuela de IA publicamos guias practicas cada semana. Unete gratis y aprende a construir con IA. Tambien en YouTube @JavadexAI.