Generación de texto con OpenAI

La generación de texto representa una de las aplicaciones más fundamentales y versátiles de los modelos de lenguaje modernos. A través de la API de OpenAI, podemos crear aplicaciones que produzcan contenido textual de alta calidad, desde respuestas conversacionales hasta documentos técnicos especializados.

Fundamentos de la API Responses

La API Responses constituye la interfaz moderna para interactuar con los modelos de OpenAI. Esta API simplifica significativamente el proceso de generación de texto, proporcionando una experiencia más directa y eficiente que las implementaciones anteriores.

La estructura básica para generar texto utiliza el método responses.create(), que acepta como parámetros principales el modelo a utilizar y el input que describe lo que queremos generar:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Explica qué es la programación orientada a objetos"
)

print(response.output_text)

Selección de modelos para generación de texto

Los modelos disponibles en OpenAI ofrecen diferentes capacidades y niveles de rendimiento. Para tareas de generación de texto, conviene pensar en familias y variantes más que en una lista rígida de aliases:

• gpt-5 / gpt-5.4: variante principal para trabajo importante de propósito general
• gpt-5.4-mini: equilibrio entre coste, latencia y capacidad
• gpt-5.4-nano: tareas sencillas, clasificación y alto volumen
• Variantes pro: reservadas para problemas especialmente difíciles

La elección del modelo depende del equilibrio entre calidad requerida, velocidad de respuesta y coste de la operación:

## Para tareas simples y rápidas
response_rapida = client.responses.create(
    model="gpt-5.4-nano",
    input="Resume este párrafo en una frase"
)

## Para análisis complejos
response_compleja = client.responses.create(
    model="gpt-5.4",
    input="Analiza las implicaciones éticas de la inteligencia artificial"
)

Salidas estructuradas con OpenAI

Las salidas estructuradas representan un avance fundamental en la interacción con modelos de lenguaje, permitiendo obtener respuestas en formatos predefinidos y consistentes. Mientras que las respuestas de texto libre son útiles para muchas aplicaciones, los sistemas profesionales requieren datos organizados que puedan procesarse automáticamente.

OpenAI ha desarrollado capacidades específicas para generar JSON estructurado, garantizando que las respuestas cumplan con esquemas predefinidos. Esta funcionalidad elimina la incertidumbre de parsear texto libre y proporciona la confiabilidad necesaria para integrar IA en aplicaciones de producción.

Fundamentos de las salidas estructuradas

Las salidas estructuradas transforman la naturaleza impredecible del texto generado en datos organizados y procesables. En lugar de recibir párrafos de texto que requieren interpretación manual, obtenemos objetos JSON que siguen esquemas específicos.

Esta aproximación resulta especialmente valiosa cuando necesitamos extraer información específica, generar datos para bases de datos, o crear respuestas que alimenten otros sistemas. La consistencia en el formato de salida permite automatizar completamente el procesamiento posterior.

from openai import OpenAI

client = OpenAI()

## Respuesta tradicional de texto libre
response = client.responses.create(
    model="gpt-5",
    input="Analiza este producto: iPhone 15 Pro"
)

print(response.output_text)
## Salida: "El iPhone 15 Pro es un smartphone premium con..."

El ejemplo anterior genera texto libre que requiere procesamiento adicional para extraer datos específicos. Las salidas estructuradas eliminan esta complejidad proporcionando formatos predecibles.

Definición de esquemas JSON

Los esquemas JSON actúan como contratos que especifican la estructura exacta de las respuestas esperadas. OpenAI utiliza JSON Schema, un estándar ampliamente adoptado para validar estructuras de datos JSON.

Un esquema define tipos de datos, propiedades requeridas, restricciones de valores y relaciones entre elementos. Esta especificación garantiza que cada respuesta cumpla exactamente con el formato esperado.

## Esquema básico para análisis de productos
product_schema = {
    "type": "object",
    "properties": {
        "nombre": {"type": "string"},
        "categoria": {"type": "string"},
        "precio_estimado": {"type": "number"},
        "caracteristicas": {
            "type": "array",
            "items": {"type": "string"}
        },
        "puntuacion": {
            "type": "integer",
            "minimum": 1,
            "maximum": 10
        }
    },
    "required": ["nombre", "categoria", "puntuacion"]
}

Este esquema establece que la respuesta debe contener un objeto con propiedades específicas, incluyendo restricciones como el rango de puntuación entre 1 y 10.

Herramientas y Function Calling en OpenAI

La capacidad de los modelos de lenguaje para interactuar con herramientas externas representa uno de los avances más significativos en el desarrollo de aplicaciones de inteligencia artificial. Mientras que los modelos por sí solos pueden generar texto y procesar información, la integración con function calling les permite ejecutar acciones específicas, consultar bases de datos, realizar cálculos complejos y conectarse con APIs externas.

Fundamentos del Function Calling

El function calling permite que los modelos de OpenAI identifiquen cuándo necesitan utilizar una función específica para responder a una consulta del usuario. En lugar de intentar generar una respuesta basada únicamente en su conocimiento interno, el modelo puede solicitar la ejecución de funciones definidas por el desarrollador.

Este mecanismo funciona mediante un proceso de dos pasos: primero, el modelo analiza la consulta del usuario y determina si necesita utilizar alguna herramienta disponible; segundo, si es necesario, genera una llamada estructurada a la función apropiada con los parámetros correctos.

from openai import OpenAI

client = OpenAI()

## Definición de una herramienta simple
tools = [
    {
        "type": "function",
        "function": {
            "name": "calcular_precio_total",
            "description": "Calcula el precio total incluyendo impuestos",
            "parameters": {
                "type": "object",
                "properties": {
                    "precio_base": {
                        "type": "number",
                        "description": "Precio antes de impuestos"
                    },
                    "tasa_impuesto": {
                        "type": "number",
                        "description": "Tasa de impuesto como decimal (ej: 0.21 para 21%)"
                    }
                },
                "required": ["precio_base", "tasa_impuesto"]
            }
        }
    }
]

Estructura de las Herramientas

Las herramientas en OpenAI se definen mediante un esquema JSON que específica el nombre de la función, su descripción y los parámetros que acepta. Esta estructura permite al modelo comprender qué funciones están disponibles y cómo utilizarlas correctamente.

La descripción de la función es crucial, ya que el modelo la utiliza para determinar cuándo y cómo usar cada herramienta. Una descripción clara y específica mejora significativamente la precisión del function calling.

## Herramienta para consultar información meteorológica
weather_tool = {
    "type": "function",
    "function": {
        "name": "obtener_clima",
        "description": "Obtiene información meteorológica actual para una ciudad específica",
        "parameters": {
            "type": "object",
            "properties": {
                "ciudad": {
                    "type": "string",
                    "description": "Nombre de la ciudad"
                },
                "unidades": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidades de temperatura"
                }
            },
            "required": ["ciudad"]
        }
    }
}

RAG (Retrieval Augmented Generation)

La Retrieval Augmented Generation representa una evolución fundamental en el desarrollo de aplicaciones de inteligencia artificial, combinando la capacidad generativa de los modelos de lenguaje con sistemas de recuperación de información. Esta técnica permite que los modelos accedan a conocimiento externo específico y actualizado, superando las limitaciones de su entrenamiento original.

Fundamentos de RAG

El concepto de RAG surge de la necesidad de proporcionar a los modelos de lenguaje acceso a información que no estaba presente durante su entrenamiento o que ha sido actualizada posteriormente. En lugar de depender únicamente del conocimiento interno del modelo, RAG implementa un proceso de dos fases: primero recupera información relevante de una base de conocimiento externa, y luego utiliza esta información como contexto para generar respuestas más precisas y actualizadas.

La arquitectura RAG se basa en tres componentes principales: un sistema de indexación que procesa y almacena documentos, un mecanismo de búsqueda que recupera información relevante, y un generador que produce respuestas utilizando tanto la consulta original como la información recuperada.

from openai import OpenAI

client = OpenAI()

## Ejemplo básico de generación con contexto externo
def generar_respuesta_con_contexto(pregunta, contexto):
    prompt = f"""
    Contexto: {contexto}
    
    Pregunta: {pregunta}
    
    Responde basándote únicamente en el contexto proporcionado.
    """
    
    response = client.responses.create(
        model="gpt-5",
        input=prompt
    )
    
    return response.output_text

Embeddings y representación vectorial

Los embeddings constituyen el núcleo técnico de los sistemas RAG, transformando texto en representaciones vectoriales que capturan el significado semántico. OpenAI proporciona modelos de embeddings especializados que convierten documentos y consultas en vectores de alta dimensionalidad, permitiendo comparaciones matemáticas de similitud semántica.

El proceso de vectorización convierte cada fragmento de texto en un vector numérico donde la distancia entre vectores refleja la similitud conceptual entre los textos originales. Esta representación permite realizar búsquedas semánticas eficientes, encontrando contenido relevante incluso cuando no existe coincidencia exacta de palabras clave.

def obtener_embeddings(textos):
    """Genera embeddings para una lista de textos"""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=textos
    )
    
    return [embedding.embedding for embedding in response.data]

## Ejemplo de uso
documentos = [
    "Python es un lenguaje de programación versátil",
    "Los algoritmos de machine learning requieren datos de calidad",
    "Las bases de datos relacionales utilizan SQL"
]

embeddings = obtener_embeddings(documentos)
print(f"Generados {len(embeddings)} embeddings de dimensión {len(embeddings[0])}")

Generación y procesamiento de imágenes con OpenAI

La inteligencia artificial generativa ha revolucionado la forma en que creamos y procesamos contenido visual. OpenAI ofrece capacidades avanzadas para trabajar con imágenes que van desde la generación de contenido visual completamente nuevo hasta el análisis detallado de imágenes existentes.

Capacidades de imagen en OpenAI

El ecosistema de OpenAI proporciona tres funcionalidades principales para el trabajo con imágenes digitales:

• Generación de imágenes: Creación de contenido visual a partir de descripciones textuales
• Análisis de imágenes: Interpretación y descripción de contenido visual existente
• Edición de imágenes: Modificación y mejora de imágenes mediante instrucciones textuales

Estas capacidades se integran perfectamente con el SDK de Python que ya conoces, manteniendo la consistencia en la interfaz de programación.

Generación de imágenes con DALL-E

La generación de imágenes utiliza modelos especializados como DALL-E que transforman descripciones textuales en contenido visual. El proceso funciona mediante prompts descriptivos que especifican el contenido, estilo y características deseadas.

from openai import OpenAI

client = OpenAI()

response = client.images.generate(
    model="dall-e-3",
    prompt="Un paisaje futurista con edificios de cristal y vehículos voladores",
    size="1024x1024",
    quality="standard",
    n=1
)

image_url = response.data[0].url
print(f"Imagen generada: {image_url}")

El modelo DALL-E 3 representa la versión más avanzada para generación de imágenes, ofreciendo mayor precisión en la interpretación de prompts y mejor calidad visual comparado con versiones anteriores.

La optimización de costes en integraciones con modelos grandes de lenguaje es una competencia clave para cualquier equipo que lleve un producto a producción. Un prompt mal diseñado, un uso poco cuidadoso del contexto o la ausencia de caché pueden multiplicar por cinco la factura mensual de OpenAI sin aportar valor adicional al usuario. Este módulo ofrece la caja de herramientas para controlar el gasto y mantener tiempos de respuesta razonables.

Qué cubre el módulo

Recorremos las palancas reales de reducción de coste que expone la plataforma de OpenAI en 2026: el flex processing para cargas que toleran latencia, el batch API para lotes nocturnos al 50 por ciento del coste, el streaming para mejorar el tiempo al primer token, el background mode para trabajos largos sin mantener conexiones abiertas y el prompt caching que aprovecha prefijos estables entre peticiones. Analizamos también el impacto de la selección de modelo: cuándo usar gpt-5-nano frente a gpt-5, cuándo activar reasoning effort alto y cuándo bajarlo.

Para qué sirve en la práctica

En un caso B2B típico como un asistente de soporte interno, aplicar prompt caching sobre las instrucciones de sistema puede reducir el coste por conversación en un 60 por ciento; mover el preprocesado de documentos al batch API puede ahorrar miles de euros al mes; y ajustar el max_completion_tokens evita pagar por respuestas infladas. Estos patrones marcan la diferencia entre una integración rentable y una experimental que no llega a escalar.

Lecciones principales incluidas

El módulo incluye tutorial-openai-flex-processing, tutorial-openai-streaming y tutorial-openai-background-mode, acompañados de ejercicios de código y un test que evalúa la selección correcta de modo de procesamiento según las restricciones de latencia y presupuesto del escenario.

El OpenAI Agents SDK es la capa oficial de OpenAI para construir agentes autónomos capaces de razonar, invocar herramientas, coordinar subagentes y mantener memoria de conversación. Frente al uso directo de la API de Chat Completions o Responses, el SDK incorpora un bucle de ejecución gestionado, tracing integrado y abstracciones de handoffs y guardrails que reducen el código repetitivo de cualquier integración agente.

Qué cubre el módulo

Este módulo presenta los conceptos fundamentales del modelo de agentes de OpenAI: definición de un agente con Agent, registro de tools con function_tool, configuración del handoff entre agentes especializados y uso de guardrails para validar entradas y salidas. Cubrimos también el patrón runner para ejecutar sesiones deterministas, la integración con el Responses API subyacente y el tracing para inspeccionar cada paso del razonamiento.

Para qué sirve en la práctica

Los agentes son la pieza central de soluciones empresariales de atención al cliente, asistentes internos sobre documentación corporativa, orquestadores de procesos administrativos y copilotos de equipos técnicos. Un escenario típico B2B es un agente que responde consultas sobre la documentación de un producto, decide cuándo escalar a un agente humano, consulta bases de datos internas mediante tools y deja trazas auditables. El SDK reduce semanas de ingeniería a días al encargarse del bucle de decisión, de la captura de excepciones en herramientas y de la serialización de mensajes.

Lecciones principales incluidas

Incluye las lecciones tutorial-openai-agents-sdk-intro y tutorial-openai-agents-concepts, junto con los retos ejercicios-openai-agents-codigo y ejercicios-openai-test-agents para practicar la construcción de agentes con herramientas reales, handoffs entre agentes especialistas y evaluación de su comportamiento frente a prompts adversariales.

Compatibilidad de OpenAI con Plataformas de IA

La compatibilidad entre diferentes plataformas de inteligencia artificial se ha convertido en una habilidad fundamental para desarrolladores que trabajan con modelos de lenguaje y sistemas de IA. Este módulo explora cómo integrar OpenAI con las principales plataformas del ecosistema de IA, permitiéndote construir soluciones más flexibles y aprovechar las fortalezas de cada proveedor.

Dominar la interoperabilidad entre servicios de IA te permite migrar proyectos entre plataformas, implementar estrategias multi-modelo y optimizar costes según las necesidades específicas de cada aplicación. En un mercado donde la diversificación de proveedores reduce riesgos y aumenta la resiliencia de los sistemas, entender estas integraciones marca la diferencia entre un desarrollador básico y uno estratégico.

Conceptos clave que aprenderás

Integración con Azure AI Foundry

Aprenderás a conectar OpenAI con Azure AI Foundry, la plataforma empresarial de Microsoft para desarrollo de aplicaciones de IA. Descubrirás cómo aprovechar la infraestructura de Azure para desplegar modelos de OpenAI con cumplimiento normativo, seguridad empresarial y escalabilidad global. Este conocimiento es especialmente valioso para proyectos corporativos que requieren certificaciones de seguridad y residencia de datos en regiones específicas.

Explorarás las diferencias entre usar OpenAI directamente y a través de Azure, incluyendo la gestión de endpoints, autenticación mediante Azure Active Directory y el uso de servicios complementarios como Azure Cognitive Search para implementar RAG (Retrieval-Augmented Generation) de nivel empresarial.

Compatibilidad con Anthropic

Comprenderás cómo trabajar con Anthropic Claude manteniendo compatibilidad con tu código de OpenAI. Aprenderás las similitudes y diferencias en las APIs, cómo adaptar prompts entre modelos y cuándo elegir Claude sobre GPT según las características del proyecto. Esta habilidad te permite implementar estrategias de fallback y comparar resultados entre diferentes modelos de lenguaje.

Descubrirás patrones de diseño para crear abstracciones que permitan cambiar de proveedor sin reescribir toda tu aplicación, una práctica esencial en arquitecturas de software profesionales que priorizan la flexibilidad y mantenibilidad.

Integración con Hugging Face

Explorarás cómo combinar OpenAI con Hugging Face, la plataforma líder en modelos de código abierto. Aprenderás a utilizar modelos de Hugging Face para tareas específicas mientras mantienes OpenAI para otras, creando pipelines híbridos que optimizan costes y rendimiento. Esta integración es crucial para proyectos que requieren modelos especializados no disponibles en OpenAI o que necesitan ejecutarse localmente por razones de privacidad.

Trabajarás con la biblioteca Transformers y entenderás cómo orquestar diferentes modelos en un mismo flujo de trabajo, desde embeddings hasta generación de texto, pasando por clasificación y análisis de sentimientos.

Aplicaciones prácticas

En el desarrollo de chatbots empresariales, la compatibilidad multi-plataforma permite implementar sistemas que usan Azure OpenAI para cumplir con regulaciones europeas de protección de datos, mientras mantienen la opción de usar modelos de Hugging Face para procesamiento local de información sensible.

Para aplicaciones de análisis de contenido, puedes combinar la capacidad de razonamiento de Claude con modelos especializados de Hugging Face para tareas específicas como detección de idiomas o clasificación de documentos técnicos, optimizando costes al usar cada modelo donde aporta más valor.

En proyectos de investigación y desarrollo, la capacidad de comparar resultados entre OpenAI, Anthropic y modelos open-source de Hugging Face acelera la experimentación y permite validar hipótesis con diferentes arquitecturas de modelos.

Prerrequisitos y nivel

Este módulo requiere conocimientos básicos de OpenAI API, incluyendo familiaridad con conceptos como prompts, completions y parámetros de generación. Debes sentirte cómodo trabajando con Python y entender conceptos fundamentales de APIs REST, autenticación mediante tokens y manejo de respuestas JSON.

Se recomienda experiencia previa con llamadas asíncronas y gestión de errores en aplicaciones que consumen servicios externos. El nivel es intermedio-avanzado, diseñado para desarrolladores que ya han trabajado con OpenAI y buscan expandir sus capacidades hacia arquitecturas multi-proveedor.

No necesitas experiencia previa con Azure, Anthropic o Hugging Face, ya que el módulo cubre los fundamentos necesarios de cada plataforma desde la perspectiva de integración con OpenAI.