Añadir funciones de IA a tu app: guía práctica con código

Añadir funciones de IA a tu app: guía práctica con código

Última actualización: 6 de junio de 2026.

La mayoría de las guías sobre «añadir IA a tu app» las escriben agencias que quieren venderte un proyecto de consultoría de seis cifras. Esta te da el enfoque orientado al código: llamadas a la API de OpenAI y Anthropic que funcionan, streaming de UI con el Vercel AI SDK, fórmulas de costos que puedes meter en una hoja de cálculo, y patrones de producción que mantienen tu app estable cuando el LLM decide portarse mal. Integrarás la IA en tu aplicación existente sin reescribir nada.

Resumen rápido — Qué puedes construir (y cuánto cuesta)

Antes de elegir qué función de IA lanzar primero, aquí tienes un desglose realista. Estas estimaciones asumen 100 usuarios activos y gpt-4o-mini como modelo predeterminado, salvo que la función requiera algo más potente.

Elige la función que sea a la vez más fácil y más valiosa para tu producto. Para la mayoría de las apps SaaS, es un asistente de chat integrado o el resumen de contenido. Empieza por ahí, comprueba que funciona y luego expande.

El resto de esta guía recorre cada paso, desde tu primera llamada a la API hasta el despliegue endurecido para producción.

Antes de escribir una línea de código — Cuándo NO añadir IA

Aquí hay algo que nadie más te dirá: no uses un LLM si una expresión regular, una consulta SQL o un simple if resuelve el problema. Cada llamada a la API de IA cuesta dinero, añade latencia e introduce no-determinismo. Antes de integrar IA en tu aplicación existente, pasa el «test de la regex».

El test de la regex

Cuándo la IA aporta valor real

Usa un LLM cuando la entrada es desordenada, no estructurada o muy variable, y cuando la salida necesita ser natural, contextual o creativa. Si tus datos son limpios y tus reglas están claras, prescinde de la IA y ahorra presupuesto.

Una comprobación rápida de costos: incluso gpt-4o-mini a $0,15 por millón de tokens de entrada se acumula. Mil usuarios haciendo 10 solicitudes al día a 500 tokens cada una = 5 millones de tokens/mes = aproximadamente $0,75/mes en costos de entrada. Barato, pero no gratis. Y si por error enrutas esas solicitudes a gpt-4o ($2,50/1M tokens), son $12,50/mes, todavía manejable, pero 16 veces más caro para tareas que no necesitan esa inteligencia adicional.

Elegir tu modelo y proveedor

Hay tres grandes proveedores que vale la pena considerar para la mayoría de los proyectos de integración de LLM en SaaS. Así están a principios de 2026.

Precios obtenidos de OpenAI, Anthropic y Google AI a junio de 2026.

Empieza barato, sube de nivel cuando sea necesario

El enfoque que te ahorra dinero: empieza con gpt-4o-mini o claude-haiku-4.5 para todo. Úsalo una semana, mide la calidad con feedback real de usuarios, y solo sube a un modelo más grande para las tareas específicas donde el modelo económico se queda corto. La mayoría de las funciones de resumen, clasificación y autocompletado funcionan perfectamente con modelos mini.

Para una visión más profunda sobre cómo construir tu stack de IA completo, consulta nuestra Guía del Stack de IA para SaaS.

Tu primera función de IA — Integración de API

Hora de escribir código. Aquí está exactamente la misma operación, una llamada de completado de chat, en Python y TypeScript. Elige el que usa tu backend.

Python (SDK de OpenAI)

# pip install openai
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def ask_ai(user_message: str) -> str:
    """Call the LLM and return the response text."""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are a helpful assistant for our SaaS product."},
            {"role": "user", "content": user_message},
        ],
        temperature=0.7,
        max_tokens=1024,
    )
    return response.choices[0].message.content

TypeScript (SDK de OpenAI)

// npm install openai
import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function askAI(userMessage: string): Promise<string> {
  const response = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: "You are a helpful assistant for our SaaS product." },
      { role: "user", content: userMessage },
    ],
    temperature: 0.7,
    max_tokens: 1024,
  });
  return response.choices[0].message.content ?? "";
}

Dónde vive este código en tu aplicación

Nunca llames a OpenAI desde tu frontend. Nunca. Este código pertenece a:

• Next.js: una ruta API (app/api/chat/route.ts)
• FastAPI: un endpoint (@app.post("/api/chat"))
• Express: un handler (router.post("/api/chat", ...))

Tu frontend envía una solicitud a tu backend, tu backend llama a OpenAI y devuelve el resultado. Así tu OPENAI_API_KEY se queda en el servidor donde le corresponde estar.

Eso es todo. Tienes una función de IA que funciona. Pero se siente lenta: el usuario hace clic en «enviar» y mira una pantalla en blanco durante 2-3 segundos. El streaming soluciona eso.

Hacerlo sentir real — Streaming de respuestas de IA

Una espera de 2-3 segundos sin ningún feedback parece que está roto. El streaming hace que la misma respuesta parezca instantánea mostrando los tokens según llegan, el efecto de máquina de escribir que has visto en ChatGPT. Todas las apps de IA en producción lo usan, y es sorprendentemente fácil de implementar.

Streaming en el servidor (Python + TypeScript)

Aquí está el enfoque en Python usando FastAPI y Server-Sent Events:

# pip install fastapi openai sse-starlette
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
import os

app = FastAPI()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

@app.post("/api/chat")
async def chat(user_message: str):
    """Stream the LLM response token by token."""
    def generate():
        stream = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a helpful SaaS assistant."},
                {"role": "user", "content": user_message},
            ],
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content

    return StreamingResponse(generate(), media_type="text/event-stream")

Y el equivalente en TypeScript usando Next.js con el Vercel AI SDK, que gestiona toda la fontanería del streaming por ti:

// npm install ai openai
// app/api/chat/route.ts (Next.js App Router)
import { openai } from "@ai-sdk/openai";
import { streamText } from "ai";

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: openai("gpt-4o-mini"),
    system: "You are a helpful SaaS assistant.",
    messages,
  });

  return result.toDataStreamResponse();
}

En el cliente: el enfoque del Vercel AI SDK

En el lado React, el hook useChat lo gestiona todo: estado de mensajes, streaming, manejo de errores:

// components/Chat.tsx
"use client";
import { useChat } from "@ai-sdk/react";

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: "/api/chat",
  });

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id} className={m.role === "user" ? "user-msg" : "ai-msg"}>
          {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} placeholder="Haz una pregunta..." />
        <button type="submit" disabled={isLoading}>Enviar</button>
      </form>
    </div>
  );
}

Un chat de IA con streaming completamente funcional en unas 40 líneas de código entre servidor y cliente. El hook useChat gestiona el array de mensajes, añade los tokens en streaming en tiempo real y maneja los estados de carga automáticamente. No tocas EventSource ni ReadableStream directamente. Para más información sobre cómo funciona el streaming internamente, la documentación del Vercel AI SDK es la referencia definitiva.

Hacer las salidas fiables — Salidas estructuradas y function calling

El texto bruto del LLM es genial para el chat. Es terrible para cualquier cosa que tu código necesite procesar. Si estás extrayendo datos, disparando acciones o construyendo UI estructurada, necesitas salidas estructuradas.

Salidas estructuradas (modo JSON)

El parámetro response_format de OpenAI fuerza al modelo a devolver JSON válido que coincida con tu esquema. Sin esperar que el modelo produzca texto parseable:

from pydantic import BaseModel
from openai import OpenAI

client = OpenAI()

class ProductReview(BaseModel):
    sentiment: str  # "positive", "negative", "neutral"
    key_points: list[str]
    rating: int  # 1-5
    recommended: bool

response = client.beta.chat.completions.parse(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Extract a structured review from user text."},
        {"role": "user", "content": "Amazing product! Fast shipping, great quality. Only downside is the price."},
    ],
    response_format=ProductReview,
)

review = response.choices[0].message.parsed
print(review.sentiment)    # "positive"
print(review.rating)       # 4
print(review.key_points)   # ["Fast shipping", "Great quality", "High price"]

El modelo está restringido a devolver exactamente los campos que defines. Sin errores de parseo, sin extracción por regex, sin «a veces devuelve Markdown y a veces no». Para la referencia completa sobre esquemas, modos y casos límite, consulta nuestra Guía de Salidas Estructuradas de LLM.

Function calling para acciones en la app

El function calling permite al LLM disparar acciones en tu aplicación: actualizar un registro en la base de datos, enviar un correo o llamar a una API externa. Defines las herramientas disponibles y el modelo decide cuándo usarlas:

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Update my email to [email protected]" }],
  tools: [
    {
      type: "function",
      function: {
        name: "update_user_profile",
        description: "Updates a field on the user's profile",
        parameters: {
          type: "object",
          properties: {
            field: { type: "string", enum: ["email", "name", "avatar_url"] },
            value: { type: "string" },
          },
          required: ["field", "value"],
        },
      },
    },
  ],
});

// The model returns a tool_call -- you execute it in your backend
const toolCall = response.choices[0].message.tool_calls?.[0];
if (toolCall?.function.name === "update_user_profile") {
  const args = JSON.parse(toolCall.function.arguments);
  await db.users.update({ [args.field]: args.value }); // Your DB call
}

El modelo no ejecuta nada directamente. Te dice qué llamar y con qué argumentos, y tú ejecutas la función real en tu backend seguro. Así es como construyes funciones de IA que van más allá del chat y realmente hacen cosas. Anthropic tiene una API de uso de herramientas similar si usas Claude.

Añadir conocimiento — RAG en 50 líneas

Tu LLM no sabe nada sobre tu producto, tu documentación ni tus usuarios. RAG (Retrieval-Augmented Generation) lo soluciona: busca primero en tus datos y luego proporciona los fragmentos relevantes al modelo como contexto. Es el patrón más común para hacer que las funciones de IA sean específicas de tu empresa.

El patrón: busca, luego pregunta

1. Embeber tus documentos en vectores (una vez, en la fase de ingesta)
2. Almacenar los vectores en una base de datos (pgvector, Pinecone, Qdrant, Weaviate)
3. Recuperar los fragmentos más relevantes cuando un usuario hace una pregunta
4. Inyectar esos fragmentos en el prompt del LLM como contexto

Implementación mínima de RAG

# pip install openai numpy psycopg2-binary pgvector
from openai import OpenAI
import numpy as np

client = OpenAI()

# Step 1: Embed a document chunk
def embed(text: str) -> list[float]:
    response = client.embeddings.create(model="text-embedding-3-small", input=text)
    return response.data[0].embedding

# Step 2: Store in pgvector (assumes table with vector column exists)
def store_chunk(cursor, text: str, embedding: list[float]):
    cursor.execute(
        "INSERT INTO documents (content, embedding) VALUES (%s, %s)",
        (text, np.array(embedding).tolist()),
    )

# Step 3: Retrieve relevant chunks
def search(cursor, query: str, top_k: int = 3) -> list[str]:
    query_embedding = embed(query)
    cursor.execute(
        """SELECT content FROM documents
           ORDER BY embedding <=> %s::vector LIMIT %s""",
        (np.array(query_embedding).tolist(), top_k),
    )
    return [row[0] for row in cursor.fetchall()]

# Step 4: Ask the LLM with context
def ask_with_context(question: str, cursor) -> str:
    chunks = search(cursor, question)
    context = "\n\n".join(chunks)
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": f"Answer using this context:\n\n{context}"},
            {"role": "user", "content": question},
        ],
    )
    return response.choices[0].message.content

Eso es todo el pipeline de RAG en unas 40 líneas. Para una configuración lista para producción con estrategias de chunking, búsqueda híbrida y evaluación, consulta nuestra guía completa para construir una aplicación RAG. Si evalúas frameworks, LangChain y LlamaIndex ofrecen abstracciones de más alto nivel.

Patrones de producción — Costos, seguridad y manejo de errores

Todo lo anterior funciona bien en desarrollo. La producción es donde las cosas se ponen interesantes. Esta sección cubre los problemas que encontrarás dos semanas después de desplegar tu función de IA, y cómo resolverlos antes de que te cuesten noches de sueño (o dinero).

Cálculo del presupuesto de tokens (lo que realmente cuesta tu función de IA)

Deja de adivinar. Aquí está la fórmula: usuarios × solicitudes/día × tokens_promedio × costo_por_token = costo mensual.

El nivel de crecimiento es donde la gente se lleva sorpresas. Con 5.000 usuarios, querrás enrutamiento de modelos: envía las solicitudes fáciles (resumen, clasificación) a gpt-4o-mini y enruta a gpt-4o solo las solicitudes complejas (razonamiento multi-paso, generación de código). Esto puede reducir los costos un 60-70%.

Otras tácticas de optimización de costos:

• Caché de prompts: OpenAI y Anthropic ofrecen hasta un 50-90% de ahorro en prefijos de prompts repetidos
• Límites max_tokens: limita la longitud de salida para que el modelo no se extienda demasiado
• Caché semántico: si un usuario hace la misma pregunta dos veces, devuelve la respuesta en caché

Para estrategias avanzadas de optimización de prompts y caché, consulta nuestra guía sobre técnicas de context engineering.

Seguridad de claves API (el patrón del proxy backend)

Debería ser obvio, pero sigue apareciendo en apps de producción: nunca expongas tus claves API en el código frontend. Ni en variables de entorno que se incluyen en el cliente. Ni en una variable JavaScript «oculta». El OWASP Top 10 para aplicaciones LLM lista la divulgación de información sensible (LLM02:2025) como un riesgo principal.

La solución es sencilla: tu frontend llama a tu API backend. Tu backend llama a OpenAI. La clave API vive exclusivamente en el servidor, cargada desde una variable de entorno o un gestor de secretos.

Implementa también limitación de velocidad por usuario para evitar que un solo usuario agote tu presupuesto de API. Lo que nos lleva a:

Limitación de velocidad por usuario

Rastrea el uso a nivel de usuario, no solo a nivel global. Un usuario del plan gratuito que descubre tu endpoint de IA y dispara 10.000 solicitudes hará muy infeliz a tu CFO.

Manejo de errores y cadenas de fallback

Las APIs de LLM se caen. Devuelven resultados incorrectos. Alcanzan límites de velocidad. Tu app necesita manejar todo esto con elegancia. Aquí hay un patrón de reintento con fallback:

import OpenAI from "openai";
import Anthropic from "@anthropic-ai/sdk";

const openai = new OpenAI();
const anthropic = new Anthropic();

async function aiWithFallback(prompt: string): Promise<string> {
  const models = [
    () => callOpenAI("gpt-4o-mini", prompt),
    () => callOpenAI("gpt-4o", prompt),
    () => callAnthropic("claude-3-5-haiku-latest", prompt),
  ];

  for (const callModel of models) {
    try {
      return await withRetry(callModel, { maxRetries: 2, baseDelay: 1000 });
    } catch (err) {
      console.warn(`Model failed, trying next fallback...`, err);
    }
  }
  // All models failed -- return cached or static response
  return "En este momento no puedo procesar tu solicitud. Por favor, inténtalo de nuevo en breve.";
}

async function withRetry<T>(fn: () => Promise<T>, opts: { maxRetries: number; baseDelay: number }): Promise<T> {
  for (let i = 0; i <= opts.maxRetries; i++) {
    try {
      return await fn();
    } catch (err: any) {
      if (i === opts.maxRetries) throw err;
      if (err?.status === 429 || err?.status >= 500) {
        await new Promise((r) => setTimeout(r, opts.baseDelay * 2 ** i)); // Exponential backoff
      } else {
        throw err; // Don't retry client errors (400, 401, etc.)
      }
    }
  }
  throw new Error("Unreachable");
}

Los principios clave: reintenta los errores 429 y 5xx con retroceso exponencial, pasa al siguiente proveedor de modelos cuando los reintentos se agoten, y siempre ten un fallback final (respuesta en caché, contenido estático o un mensaje de error claro). Nunca dejes que un fallo de IA haga caer tu app.

Cómo Techsy aborda el desarrollo de funciones de IA

Comenzamos cada proyecto de IA con la misma pregunta de la sección 3: «¿Esto realmente necesita un LLM, o hay una solución más simple?» Te sorprendería cuántas veces la respuesta es «una consulta SQL bien diseñada maneja el 80% de esto».

Cuando la IA es la elección correcta, este es nuestro proceso:

1. Prototipar rápido — prueba de concepto funcional en 1-2 semanas usando gpt-4o-mini y la arquitectura más simple posible
2. Medir con usuarios reales — no benchmarks sintéticos, satisfacción real de usuarios (pulgares arriba/abajo, tasa de completado de tareas)
3. Iterar con evaluaciones — evaluaciones automatizadas de LLM que detectan regresiones de calidad antes que los usuarios
4. Endurecer para producción — límites de velocidad, cadenas de fallback, monitoreo de costos y los patrones de seguridad de esta guía
5. Optimizar costos — enrutamiento de modelos, caché de prompts y ajuste del tamaño de modelos por función

Qué esperar en proyectos reales: orientación basada en benchmarks públicos

No publicamos métricas de clientes sin permiso, pero las siguientes cifras se basan en benchmarks públicos de modelos y datos de precios de API disponibles públicamente, útiles como objetivos de ingeniería antes de tener tus propios datos:

• Latencia de primer token en streaming con gpt-4o-mini suele situarse entre 200ms y 600ms bajo carga normal. gpt-4o es similar o ligeramente mayor. El percentil p95 suele ser 1,5 a 2 veces la mediana.
• Costo por conversación para una respuesta de soporte típica de 600 tokens (400 entrada + 200 salida) en gpt-4o-mini: (400/1.000.000 × $0,15) + (200/1.000.000 × $0,60) = $0,000060 + $0,000120 = $0,00018 por respuesta, menos de un centavo incluso a 5.000 respuestas al día.
• Overhead de RAG: embeber cada consulta con text-embedding-3-small ($0,02/1M tokens) añade aproximadamente $0,000010 por búsqueda, insignificante comparado con la llamada al completion.

Estos son puntos de partida representativos. Si instrumentas tus propias llamadas, los números reales variarán según la longitud del prompt, el tamaño del mensaje de sistema y los picos de tráfico. Si has ejecutado integraciones construidas por Techsy y quieres compartir datos de benchmark para esta guía, contáctanos.

Hemos construido chats de IA con streaming, bases de conocimiento impulsadas por RAG y sistemas de clasificación basados en IA para productos SaaS. Los patrones de esta guía son los mismos que usamos en proyectos de clientes, nada está oculto.

¿Estás desarrollando funciones de IA y necesitas una segunda opinión? Obtén una revisión de arquitectura gratuita.

Preguntas frecuentes

¿Cómo añado funciones de IA a mi SaaS sin reconstruirlo desde cero?

No lo reconstruyes. Añades una ruta API backend que llama a OpenAI o Anthropic, la conectas a tu UI existente y despliegas. Los ejemplos de código en esta guía muestran exactamente eso: un nuevo endpoint, no una nueva arquitectura. Empieza con una función como chat o resumen y amplía desde ahí.

¿Cuál es la forma más rápida de integrar OpenAI en una aplicación existente?

Instala el SDK (pip install openai o npm install openai), crea una ruta API backend, llama a chat.completions.create() y devuelve el resultado. Con el hook useChat del Vercel AI SDK, puedes tener un chat de IA en streaming funcionando en menos de 30 minutos.

¿Cuánto cuesta añadir funciones de IA a una app SaaS?

Los costos de API para una app de 1.000 usuarios van de $15 a $150/mes dependiendo del modelo y los patrones de uso. gpt-4o-mini a $0,15/1M tokens de entrada mantiene los costos muy bajos. El tiempo de desarrollo es típicamente de 1-4 semanas para tu primera función. Consulta la sección de cálculo del presupuesto de tokens para escenarios detallados.

¿Debo usar RAG o fine-tuning para añadir IA a mi producto?

RAG para el 90% de los casos de uso. Fine-tuning solo cuando necesitas que el modelo aprenda un estilo específico o conocimiento de dominio que no se puede proporcionar a través del contexto. RAG es más barato, más rápido de implementar y mucho más fácil de actualizar: simplemente añades nuevos documentos a tu vector store en lugar de reentrenar un modelo.

¿Cómo evito exponer mi clave API de OpenAI en una aplicación web?

Nunca llames a la API de OpenAI desde el frontend. Crea un proxy backend: tu frontend llama a tu API, tu backend llama a OpenAI. Almacena la clave en variables de entorno en el lado del servidor. Añade limitación de velocidad por usuario para que nadie pueda abusar de tu endpoint.

¿Cuánto tiempo lleva añadir funciones de IA a una aplicación existente?

Una función de chat básica lleva 1-2 días. El streaming de UI añade 2-3 días. RAG con los datos de tu empresa lleva 1-2 semanas. El endurecimiento completo para producción con límites de velocidad, manejo de errores y controles de costos lleva 2-4 semanas. Puedes lanzar la versión básica en días e iterar desde ahí.

¿Cuándo usar GPT-4o frente a Claude frente a Gemini?

GPT-4o para tareas generales con el ecosistema más amplio y el mejor soporte de herramientas. Claude Sonnet 4.6 para documentos largos, seguimiento preciso de instrucciones y tareas de codificación. Gemini 2.5 Pro para trabajo multimodal (imágenes + texto) e integración con Google Cloud. Empieza con GPT-4o-mini para ahorrar costos y solo sube de nivel cuando puedas medir una diferencia de calidad.

¿Cómo gestiono los errores de IA en producción?

Implementa lógica de reintento con retroceso exponencial para errores 429 (límite de velocidad) y 5xx. Construye una cadena de modelos de fallback: prueba tu modelo principal, cae de vuelta a un proveedor alternativo y luego a una respuesta en caché o estática. Nunca dejes que un fallo de IA haga caer tu app o muestre una pantalla en blanco.

¿Qué funciones de IA debería tener una app SaaS en 2026?

Empieza con la función de mayor valor y menor complejidad para tu producto específico. Para la mayoría de los SaaS: búsqueda potenciada por IA, resumen de contenido o un asistente integrado. Consulta la tabla de Resumen rápido al inicio de esta guía para estimaciones de costos y dificultad por tipo de función.

¿Cómo sé si mi función de IA realmente funciona?

Configura evaluaciones de LLM: pruebas automatizadas que miden la calidad de las respuestas, la relevancia y la seguridad en un conjunto de entradas representativas. Rastrea métricas de satisfacción de usuarios como calificaciones de pulgares arriba/abajo y frecuencia de preguntas de seguimiento. Compara la tasa de completado de tareas con asistencia de IA frente al flujo sin IA. Si los usuarios no completan las tareas más rápido o con más éxito, la función necesita trabajo.

Tu lista de verificación para lanzar tu función de IA

Ya tienes el panorama completo. Este es tu camino paso a paso para lanzarla:

1. Elige tu función — usa la tabla de Resumen rápido para elegir la opción de mayor valor y menor dificultad para tu producto
2. Pasa el test de la regex — confirma que la IA es genuinamente la herramienta adecuada para esta tarea
3. Empieza con un modelo económico — gpt-4o-mini o claude-haiku-4.5, mide la calidad antes de subir de nivel
4. Construye la llamada API básica — Python o TypeScript, detrás de un proxy backend
5. Añade streaming — el Vercel AI SDK hace esto trivial para apps React
6. Añade salidas estructuradas — si tu función necesita datos parseables en lugar de texto libre
7. Calcula tu presupuesto de tokens — usuarios × solicitudes × tokens × costo = factura mensual
8. Implementa límites de velocidad y manejo de errores — límites por usuario, lógica de reintento, cadena de fallback
9. Despliega y mide — rastrea la satisfacción del usuario, no solo si la API devuelve 200

Tu primera función de IA está más cerca de lo que crees. La parte más difícil no es el código, es decidir qué función construir primero. Elige una, lánzala esta semana e itera basándote en lo que te digan los usuarios reales.

Fuentes

• Precios de la API de OpenAI
• Precios de la API de Anthropic Claude
• Vercel AI SDK — Streaming
• Guía de Salidas Estructuradas de OpenAI
• Mejores Prácticas de Producción de OpenAI
• OWASP Top 10 para Aplicaciones LLM 2025
• Documentación de Uso de Herramientas de Anthropic
• Tutorial de RAG de LangChain
• Introducción al RAG de LlamaIndex