Construyendo con la API de OpenAI: GPTs, Assistants y Function Calling 
Si eres desarrollador y todavía no has integrado la API de OpenAI en algún proyecto, probablemente es solo cuestión de tiempo. El ecosistema de OpenAI en 2026 es maduro, bien documentado, y ofrece herramientas específicas para distintos tipos de aplicaciones: desde chatbots simples hasta agentes complejos con acceso a herramientas externas.
En esta guía práctica vamos a explorar los tres pilares principales del ecosistema developer de OpenAI: la Assistants API, el Function Calling, y el GPT Builder. Con ejemplos de código reales y estimaciones de costos para que puedas planificar.
El ecosistema OpenAI para developers en 2026
Antes de entrar en detalles, un mapa rápido:
- Chat Completions API — La API base. Envías mensajes, recibes respuestas. Ideal para casos simples.
- Assistants API — Para construir asistentes con memoria, archivos y herramientas.
- Function Calling / Tool Use — Para dar a los modelos acceso a funciones externas.
- GPT Builder — Interfaz no-code para crear GPTs personalizados (ChatGPT Plus).
- Responses API — Nueva API unificada que combina lo mejor de Chat Completions y Assistants.
1. La Assistants API: construye agentes con memoria
La Assistants API es el componente más poderoso para developers que quieren construir aplicaciones con estado — es decir, que recuerdan conversaciones anteriores y pueden acceder a archivos.
Conceptos clave
- Assistant — El agente con su configuración (modelo, instrucciones, herramientas)
- Thread — Una conversación específica (puede durar días o semanas)
- Run — La ejecución de una respuesta dentro de un Thread
- File — Documentos que el asistente puede procesar y buscar
Ejemplo completo: asistente de soporte técnico
from openai import OpenAI
client = OpenAI(api_key="tu-api-key")
# 1. Crear el asistente (se hace una vez)
assistant = client.beta.assistants.create(
name="Soporte Técnico yoDEV",
instructions="""
Eres un asistente de soporte para desarrolladores de LatAm.
Responde en español, con ejemplos de código cuando sea útil.
Si no sabes la respuesta, di que vas a investigar.
""",
model="gpt-4o",
tools=[
{"type": "file_search"}, # búsqueda en documentos
{"type": "code_interpreter"} # ejecutar código
]
)
print(f"Assistant ID: {assistant.id}")
# Guarda este ID — lo reutilizarás
# 2. Crear un thread para un usuario
thread = client.beta.threads.create()
# 3. Agregar el mensaje del usuario
client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="¿Cómo configuro CORS en Express para producción?"
)
# 4. Ejecutar el asistente
run = client.beta.threads.runs.create_and_poll(
thread_id=thread.id,
assistant_id=assistant.id
)
# 5. Obtener la respuesta
if run.status == "completed":
messages = client.beta.threads.messages.list(thread_id=thread.id)
print(messages.data[0].content[0].text.value)
Ventaja clave: los threads persisten
A diferencia del Chat Completions simple, los threads mantienen el historial automáticamente. El próximo mensaje que el usuario envíe al mismo thread ya incluye toda la conversación anterior. OpenAI gestiona la memoria por ti.
2. Function Calling: conecta el modelo con el mundo real
Function Calling (o “Tool Use”) es lo que transforma un modelo de lenguaje en un agente que puede ejecutar acciones reales: consultar una base de datos, llamar a una API externa, modificar un archivo, enviar un email.
Cómo funciona el flujo
1. Tú → Defines las funciones disponibles (JSON Schema)
2. Usuario → Hace una pregunta
3. Modelo → Decide qué función llamar y con qué parámetros
4. Tu código → Ejecuta la función
5. Tú → Devuelves el resultado al modelo
6. Modelo → Genera la respuesta final usando el resultado
Ejemplo: asistente con acceso a base de datos
import json
from openai import OpenAI
client = OpenAI()
# Define las herramientas disponibles
tools = [
{
"type": "function",
"function": {
"name": "buscar_usuarios",
"description": "Busca usuarios en la base de datos por nombre o email",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Término de búsqueda (nombre o email)"
},
"limite": {
"type": "integer",
"description": "Número máximo de resultados",
"default": 10
}
},
"required": ["query"]
}
}
},
{
"type": "function",
"function": {
"name": "obtener_estadisticas",
"description": "Obtiene estadísticas del sistema",
"parameters": {
"type": "object",
"properties": {
"periodo": {
"type": "string",
"enum": ["hoy", "semana", "mes"],
"description": "Período de las estadísticas"
}
},
"required": ["periodo"]
}
}
}
]
# Tus funciones reales
def buscar_usuarios(query: str, limite: int = 10):
# Aquí va tu lógica real de DB
return [
{"id": 1, "nombre": "María García", "email": "maria@ejemplo.com"},
{"id": 2, "nombre": "Carlos López", "email": "carlos@ejemplo.com"}
]
def obtener_estadisticas(periodo: str):
# Aquí va tu lógica real
return {"usuarios_activos": 1250, "registros_hoy": 45, "periodo": periodo}
# El agente en acción
def run_agent(user_message: str):
messages = [{"role": "user", "content": user_message}]
response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools
)
# Si el modelo quiere usar una herramienta
while response.choices[0].finish_reason == "tool_calls":
tool_calls = response.choices[0].message.tool_calls
messages.append(response.choices[0].message)
for call in tool_calls:
args = json.loads(call.function.arguments)
# Ejecutar la función correspondiente
if call.function.name == "buscar_usuarios":
result = buscar_usuarios(**args)
elif call.function.name == "obtener_estadisticas":
result = obtener_estadisticas(**args)
# Agregar el resultado al contexto
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result, ensure_ascii=False)
})
# Siguiente llamada con los resultados
response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools
)
return response.choices[0].message.content
# Uso
resultado = run_agent("¿Cuántos usuarios registramos esta semana?")
print(resultado)
# "Esta semana tuvieron 45 nuevos registros. Los usuarios activos totales son 1,250."
3. Structured Outputs: respuestas siempre en el formato correcto
Una de las adiciones más útiles: Structured Outputs garantizan que el modelo responda siempre con un JSON que sigue exactamente tu esquema. Se acabaron las respuestas mal formateadas.
from pydantic import BaseModel
from typing import List
class ExtraccionCV(BaseModel):
nombre: str
email: str
experiencia_años: int
tecnologias: List[str]
nivel: str # junior, semi-senior, senior
# El modelo responde SIEMPRE con este formato
respuesta = client.beta.chat.completions.parse(
model="gpt-4o",
messages=[
{"role": "system", "content": "Extrae información de CVs de desarrolladores"},
{"role": "user", "content": cv_texto}
],
response_format=ExtraccionCV
)
candidato = respuesta.choices[0].message.parsed
print(f"Nombre: {candidato.nombre}")
print(f"Tecnologías: {', '.join(candidato.tecnologias)}")
print(f"Nivel: {candidato.nivel}")
4. GPT Builder: el camino sin código
Si tu objetivo es crear un asistente personalizado sin escribir código, el GPT Builder de ChatGPT te permite configurar todo desde una interfaz visual:
- Instrucciones de comportamiento
- Archivos de conocimiento (PDFs, documentos)
- Acciones personalizadas (conecta tu API)
- Imagen y nombre del GPT
Los GPTs que creas pueden ser privados (solo tú), compartidos con link, o publicados en el GPT Store.
Cuándo usar GPT Builder vs API: Si necesitas integrar el asistente en tu propia aplicación, la API es el camino. Si solo quieres un asistente personalizado dentro de ChatGPT para tu equipo, el GPT Builder es mucho más rápido.
Precios en 2026: estimaciones reales para LatAm
La forma más eficiente de controlar costos es entender la relación tokens ↔ precio. Una referencia rápida:
| Modelo | Entrada (1M tokens) | Salida (1M tokens) |
|---|---|---|
| GPT-4o | $2.50 | $10.00 |
| GPT-4o mini | $0.15 | $0.60 |
| GPT-4.1 | $2.00 | $8.00 |
| o3-mini | $1.10 | $4.40 |
¿Cuánto es 1M de tokens en la práctica?
1 token ≈ 0.75 palabras en inglés, ~0.6 palabras en español
- Una conversación de chat normal (10 turnos): ~3,000-5,000 tokens
- Análisis de un documento de 10 páginas: ~15,000 tokens
- Respuesta generada de extensión media: ~500-1,000 tokens
Estimaciones de costo por caso de uso (GPT-4o):
| Caso de uso | Tokens aprox. | Costo aprox. |
|---|---|---|
| Chatbot (1 conversación) | 2,000 tokens | $0.002 |
| Análisis de código (función media) | 1,500 tokens | $0.0015 |
| Generación de report (1 página) | 3,000 tokens | $0.003 |
| Procesamiento de 100 emails | 50,000 tokens | $0.05 |
Para la mayoría de aplicaciones medianas, el costo de API es muy manejable. Si tu app procesa 10,000 conversaciones/mes con GPT-4o mini, estarías gastando aproximadamente $15-30 USD/mes en API.
Tip LatAm: OpenAI acepta tarjetas internacionales. Puedes cargar créditos desde $5 USD para empezar a experimentar. El Batch API ofrece 50% de descuento para procesamiento asíncrono (ideal para tareas que no son en tiempo real).
Ejemplo práctico: extractor de datos de emails
from openai import OpenAI
from pydantic import BaseModel
from typing import Optional
client = OpenAI()
class EmailData(BaseModel):
remitente: str
asunto: str
accion_requerida: Optional[str]
urgencia: str # "alta", "media", "baja"
resumen: str
def procesar_email(contenido_email: str) -> EmailData:
respuesta = client.beta.chat.completions.parse(
model="gpt-4o-mini", # más barato para procesamiento masivo
messages=[
{
"role": "system",
"content": "Extrae información estructurada de emails de soporte técnico"
},
{
"role": "user",
"content": f"Email a procesar:\n\n{contenido_email}"
}
],
response_format=EmailData
)
return respuesta.choices[0].message.parsed
# Uso
email = """
De: juan@startup.com
Para: soporte@empresa.com
Asunto: URGENTE - Producción caída
Hola, llevamos 2 horas sin poder acceder al dashboard de producción.
Los usuarios están reportando errores 500. Necesitamos ayuda ya.
"""
datos = procesar_email(email)
print(f"Urgencia: {datos.urgencia}")
print(f"Acción: {datos.accion_requerida}")
# Urgencia: alta
# Acción: Revisar logs del dashboard de producción y resolver error 500
Tips para reducir costos sin sacrificar calidad
1. Usa el modelo correcto para cada tarea
- GPT-4o mini para clasificaciones, extracción de datos, resúmenes simples
- GPT-4o para razonamiento complejo, generación de código, análisis profundo
2. Caching de prompts
OpenAI cachea prompts repetidos (descuento del 50% en tokens de entrada para prompts idénticos al inicio del contexto).
3. Batch API para tareas no urgentes
# En lugar de 10,000 llamadas individuales...
# Usa el Batch API con 50% de descuento
client.batches.create(
input_file_id="file-xxx",
endpoint="/v1/chat/completions",
completion_window="24h"
)
4. Streaming para mejor UX
No reduce costos, pero hace que las respuestas lleguen más rápido al usuario:
with client.chat.completions.stream(
model="gpt-4o",
messages=[{"role": "user", "content": "Genera un README para este proyecto..."}]
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
¿Por dónde empezar?
Si recién estás entrando al ecosistema OpenAI:
- Crea una cuenta en platform.openai.com
- Carga $5-10 USD de créditos para experimentar
- Empieza con el Playground — interfaz web para probar modelos sin código
- Tu primera app: un chatbot simple con Chat Completions
- Cuando necesites memoria: migra a Assistants API
- Cuando necesites acciones: agrega Function Calling
La curva de aprendizaje es suave. En un fin de semana puedes tener tu primer asistente funcional integrado en una app web.
¿Qué tipo de aplicaciones están construyendo con la API de OpenAI en sus proyectos? ¿Tienen casos de uso específicos para el mercado de LatAm que quieran compartir? ¡Los comentarios son el lugar perfecto para intercambiar ideas y aprender juntos! 
Explora y comparte tus experimentos de código en nuestro Code Studio — el sandbox de la comunidad yoDEV.