- ¿Qué es la Llamada a Funciones?
- ¿Qué son las Salidas Estructuradas?
- Llamada a Funciones y Salidas Estructuradas
- Cómo Verificar la Llamada a Funciones y las Salidas Estructuradas en Novita AI
- Cómo Usar la Llamada a Funciones en Novita AI
- Cómo Usar las Salidas Estructuradas en Novita AI
- Preguntas Frecuentes
Los modelos modernos de IA están evolucionando más allá de la simple generación de texto. Con funciones como Llamada a Funciones y Salidas Estructuradas, los desarrolladores pueden crear aplicaciones más inteligentes y fiables. En Novita AI, ahora puedes verificar rápidamente si un modelo admite estas capacidades directamente desde la Consola, haciendo la integración más rápida y eficiente.
¿Qué es la Llamada a Funciones?
La llamada a funciones es una capacidad en IA, especialmente con modelos de lenguaje grandes (LLM), que permite al modelo interactuar con funciones, herramientas o API externas para realizar tareas específicas más allá de generar respuestas de texto. En lugar de solo producir texto, el modelo identifica cuándo se debe invocar una función particular según el mensaje del usuario, determina la función correcta a ejecutar y especifica los parámetros necesarios para esa función. La ejecución real de la función es manejada por un sistema o aplicación externa, no por el modelo en sí.
https://www.youtube.com/watch?v=aqdWSYWC\_LI
¿Cómo funciona la Llamada a Funciones?
La Llamada a Funciones permite que los modelos de IA interactúen con herramientas externas, API o funciones internas durante una conversación. En lugar de simplemente generar texto, el modelo puede reconocer cuándo se necesita una función, generar la llamada a función correcta con argumentos estructurados y ejecutarla para obtener resultados. Esto une la brecha entre la comprensión del lenguaje natural y la acción en el mundo real, permitiendo a los modelos realizar tareas como obtener datos en tiempo real, gestionar flujos de trabajo o desencadenar acciones del sistema automáticamente.
¿Cuáles son los beneficios de la Llamada a Funciones?
- Interacción con el mundo real: Los modelos pueden desencadenar acciones, no solo proporcionar información.
- Automatización: Optimiza procesos como la recuperación de datos, reservas, envíos de formularios y más.
- Comprensión estructurada: En lugar de depender solo de la generación de texto, el modelo organiza la salida en formatos predefinidos, reduciendo errores.
- Casos de uso mejorados: Crea aplicaciones dinámicas, asistentes y sistemas más fiables y eficientes.
- Eficiencia del desarrollador: Al saber de antemano que un modelo admite la Llamada a Funciones, puedes planificar integraciones más rápido sin modificaciones pesadas.
¿Qué son las Salidas Estructuradas?
Las salidas estructuradas se refieren a la capacidad de los modelos de lenguaje grandes (LLM) de generar respuestas que se ajustan a un formato predefinido y específico, en lugar de producir texto libre. Estas salidas suelen estar en formatos legibles por máquina como JSON, XML, plantillas rellenadas o datos tabulares, lo que facilita su análisis, validación e integración en sistemas de software o flujos de trabajo.
Cómo se generan las Salidas Estructuradas
- Técnicas de indicaciones: El modelo se guía mediante mensajes cuidadosamente elaborados para producir la salida en el formato deseado.
- API de Llamada a Funciones: De manera más robusta, las salidas estructuradas se pueden generar utilizando interfaces de llamada a funciones donde el modelo devuelve argumentos que se ajustan estrictamente al esquema de una función, a menudo forzado mediante parámetros como
strict: true. - Guía de Máquina de Estados Finitos (FSM): Internamente, la generación se puede restringir para que cada token producido cumpla con las reglas del formato de salida, reduciendo errores en la estructura.
Casos de uso y beneficios
- Extraer datos estructurados de texto no estructurado, como detalles de eventos, información de usuarios o parámetros de consulta.
- Desencadenar API o funciones externas con parámetros precisos generados por el modelo.
- Construir flujos de trabajo complejos de varios pasos que dependen de un intercambio de datos consistente y validado.
- Mejorar la fiabilidad en aplicaciones como chatbots, extracción de datos y sistemas de automatización al reducir la ambigüedad en las salidas del modelo.
Llamada a Funciones y Salidas Estructuradas
| Aspecto | 🛠️ Llamada a Funciones | 🗂️ Salidas Estructuradas |
|---|---|---|
| Propósito | Desencadenar una función externa | Devolver información estructurada |
| Orientación | Orientada a la acción | Orientada a la información |
| Salida | Nombre de la función + argumentos | Datos estructurados predefinidos (ej. JSON) |
| Ejemplo | Llamar a una API del clima para obtener el pronóstico | Devolver un informe del clima en formato JSON |
| Escenario de uso | Cuando necesitas que el modelo realice una acción | Cuando necesitas datos limpios y analizables sin una acción |
Cómo Verificar la Llamada a Funciones y las Salidas Estructuradas en Novita AI
1: Inicia sesión en Novita AI
Una vez que llegues a la página de inicio de Novita AI, simplemente presiona el botón “Iniciar sesión” o “Comenzar” en la esquina superior derecha. Puedes iniciar sesión fácilmente con Google, GitHub, Hugging Face o simplemente con tu Correo electrónico, ¡tú decides!
¡Haz clic en “API de Modelo” en la Consola!
Una vez que hayas iniciado sesión, serás dirigido al panel de la Consola de Novita. Desde la parte superior, haz clic en “API de Modelo”. Esta sección te da acceso a una lista completa de modelos disponibles, junto con información detallada sobre sus capacidades, incluyendo si admiten Llamada a Funciones y Salidas Estructuradas.
¡Elige tu modelo y verifícalo!
Simplemente encuentra el modelo que te interesa, haz clic en él y se abrirá un panel a la derecha. En “Capacidades Admitidas”, verás al instante si se admiten Llamada a Funciones y Salidas Estructuradas.
Cómo Usar la Llamada a Funciones en Novita AI
1. Inicializar el Cliente
Primero, necesitas inicializar el cliente con tu clave API de Novita.
from openai import OpenAI
import json
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Obtén la clave API de Novita AI desde: https://novita.ai/settings/key-management.
api_key="<TU Clave API de Novita AI>",
)
model = "meta-llama/llama-4-maverick-17b-128e-instruct-fp8"
- Definir la Función a Llamar
A continuación, define la función de Python que el modelo puede llamar. En este ejemplo, es una función para obtener información meteorológica.
# Función de ejemplo para simular la obtención de datos del clima.
def get_weather(location):
"""Recupera el clima actual para una ubicación determinada."""
print("Llamando a la función get_weather con ubicación: ", location)
# En una aplicación real, llamarías a una API meteorológica externa aquí.
# Este es un ejemplo simplificado que devuelve datos fijos.
return json.dumps({"location": location, "temperature": "60 grados Fahrenheit"})
2. Construir la Solicitud a la API con Herramientas y Mensaje del Usuario
Ahora, crea la solicitud a la API hacia el endpoint de Novita. Esta solicitud incluye el parámetro tools, definiendo las funciones que el modelo puede usar, y el mensaje del usuario.
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Obtener el clima de una ubicación, el usuario debe proporcionar una ubicación primero",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "La ciudad y el estado, ej. San Francisco, CA",
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "¿Cuál es el clima en San Francisco?"
}
]
# Enviemos la solicitud e imprimamos la respuesta.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Verifica si la respuesta contiene llamadas a herramientas si estás en producción.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
3. Salida
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
4. Responder con el Resultado de la Llamada a Función y Obtener la Respuesta Final
El siguiente paso es procesar la llamada a función, ejecutar la función get_weather y enviar el resultado de vuelta al modelo para generar la respuesta final al usuario.
# Asegúrate de que tool_call esté definido desde el paso anterior
if tool_call:
# Extiende el historial de conversación con el mensaje de llamada a herramienta del asistente
messages.append(response.choices[0].message)
function_name = tool_call.function.name
if function_name == "get_weather":
function_args = json.loads(tool_call.function.arguments)
# Ejecuta la función y obtén la respuesta
function_response = get_weather(
location=function_args.get("location"))
# Agrega la respuesta de la función a los mensajes
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Obtén la respuesta final del modelo, ahora con el resultado de la función
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Nota: No incluyas el parámetro tools aquí.
)
print(answer_response.choices[0].message)
5. Salida
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
Cómo Usar las Salidas Estructuradas en Novita AI
1. Inicializar el Cliente
Primero, necesitas inicializar el cliente con tu clave API de Novita.
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Obtén la clave API de Novita AI desde: https://novita.ai/settings/key-management.
api_key="<TU Clave API de Novita AI>",
)
# Ve a la página [Modelos](https://novita.ai/models) para ver los modelos que admiten `Salidas Estructuradas`.
model = "mistralai/mistral-7b-instruct"
2. Definir el Esquema JSON
Este ejemplo crea un esquema para extraer información de gastos de la entrada del usuario.
# Define el prompt del sistema para el seguimiento de gastos.
system_prompt = """Eres un asistente de seguimiento de gastos.
Extrae la información de gastos de la entrada del usuario y formatéala según el esquema proporcionado."""
# Define el esquema JSON para la respuesta estructurada.
response_format = {
"type": "json_schema",
"json_schema": {
"name": "expense_tracking_schema",
"schema": {
"type": "object",
"properties": {
"expenses": {
"type": "array",
"items": {
"type": "object",
"properties": {
"description": {
"type": "string",
"description": "Descripción del gasto"
},
"amount": {
"type": "number",
"description": "Cantidad gastada en dólares"
},
"date": {
"type": "string",
"description": "Cuándo ocurrió el gasto"
},
"category": {
"type": "string",
"description": "Categoría del gasto (ej. comida, oficina, viajes)"
}
},
"required": [
"description",
"amount"
]
}
},
"total": {
"type": "number",
"description": "Cantidad total de todos los gastos"
}
},
"required": [
"expenses",
"total"
],
},
},
}
3. Solicitar la API de chat completion
Ahora, haz la solicitud de chat completion al endpoint de Novita.
Esta solicitud incluye el parámetro response_format, definiendo el esquema JSON que definimos en el paso anterior.
chat_completion = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": system_prompt,
},
{
"role": "user",
"content": """Gasté $120 en una cena en un restaurante italiano el viernes pasado con mis colegas.
También compré suministros de oficina por $45 el lunes.""",
},
],
max_tokens=1024,
temperature=0.8,
stream=False,
response_format=response_format,
)
response_content = chat_completion.choices[0].message.content
# Analizar y embellecer el JSON
try:
json_response = json.loads(response_content)
prettified_json = json.dumps(json_response, indent=2)
print(prettified_json)
except json.JSONDecodeError:
print("No se pudo analizar la respuesta como JSON. Respuesta sin procesar:")
print(response_content)
4. Salida:
{
"expenses": [
{
"date": "2023-03-17",
"description": "Cena en restaurante italiano",
"amount": 120,
"category": "Comida y Bebida"
},
{
"date": "2023-03-13",
"description": "Suministros de oficina",
"amount": 45,
"category": "Suministros de Oficina"
}
],
"total": 165
}
La Llamada a Funciones y las Salidas Estructuradas amplían significativamente lo que los modelos de IA pueden hacer. Ya sea que necesites automatizar flujos de trabajo, obtener datos en tiempo real o extraer información estructurada, Novita AI facilita encontrar modelos que se adapten a tus necesidades. ¡Empieza a construir aplicaciones más inteligentes hoy mismo explorando modelos en la Consola de Novita!
Preguntas Frecuentes
¿Qué es la Llamada a Funciones en los modelos de IA?
Permite que los modelos activen herramientas o API externas generando llamadas a funciones estructuradas basadas en las indicaciones del usuario.
¿Qué son las Salidas Estructuradas?
Las Salidas Estructuradas se refieren a respuestas del modelo en formatos estrictos y legibles por máquina, como JSON, ideales para una integración fácil.
¿En qué se diferencian la Llamada a Funciones y las Salidas Estructuradas?
La Llamada a Funciones está impulsada por la acción (ej. obtener el clima), mientras que las Salidas Estructuradas se centran en devolver datos limpios y formateados.
Novita AI es la plataforma integral en la nube que impulsa tus ambiciones de IA. APIs integradas, sin servidor, instancias GPU — las herramientas rentables que necesitas. Elimina la infraestructura, comienza gratis y haz realidad tu visión de IA.
