Llama 3.3 70B Function Calling: Integración sin esfuerzo para un mejor rendimiento

Puntos clave

Qué hace: Ejecuta recuperación de datos en tiempo real, operaciones del sistema y flujos de trabajo automatizados.

Qué modelos lo admiten: Serie Llama 3, serie GPT, Gemma 2 y Mistral nemo.

Cómo implementarlo: Instala APIs a través de Novita AI “Model Library”, luego implementa con el framework Langchain.

El function calling es una técnica que mejora significativamente las capacidades de los modelos de lenguaje grandes (LLMs) al permitirles interactuar con el mundo exterior. En lugar de solo generar texto, los LLMs pueden utilizar el function calling para ejecutar tareas específicas, acceder a información en tiempo real y realizar operaciones complejas. Este artículo explorará el concepto de function calling, sus aplicaciones prácticas y cómo modelos como Llama 3.3 70B lo están haciendo más accesible.

¿Qué problemas puede resolver el function calling?

1. Acceso a información en tiempo real

• Consultar los precios de acciones más recientes
• Obtener datos meteorológicos actuales
• Acceder a noticias de última hora

2. Interacciones con el sistema

• Enviar correos electrónicos
• Publicar en redes sociales
• Consultar y escribir en bases de datos

3. Automatización de flujos de trabajo

• Extracción y procesamiento de datos
• Ejecución de tareas de varios pasos
• Automatización de análisis complejos

4. Precisión de datos

• Asegurar la actualidad de la información
• Proporcionar resultados de consultas precisos
• Reducir errores por datos desactualizados

¿Qué es el function calling?

En esencia, el function calling es la capacidad de un LLM de reconocer cuándo una tarea específica requiere una función o herramienta externa y luego generar datos estructurados (típicamente en formato JSON) para ejecutar la función. Estos datos estructurados incluyen el nombre de la función y los argumentos necesarios. Básicamente, el function calling actúa como un puente entre el vasto conocimiento de la IA y las acciones tangibles. Permite a los agentes de IA o chatbots realizar tareas específicas o acceder a datos y servicios externos.

Modelos compatibles con function calling

Muchos LLMs y plataformas ahora admiten function calling. Puedes instalar la API a través de la página “Model Library” de Novita AI, e implementar el function calling mediante langchain.

• Llama 3.3: La versión de 70 mil millones de parámetros ha mostrado un buen rendimiento en pruebas de function calling al identificar con éxito cuándo y qué funciones llamar según las solicitudes de los usuarios.
  • Llama 3.3 70B
  • Llama 3.1 70B
  • Llama 3.1 8B
• Mistral: Modelos como Mistral-Large-2 demuestran éxito en function calling dentro de entornos como watsonx.ai.
  • Mistral Nemo
• Gemini: Los modelos Gemini de Google también admiten function calling con varios ejemplos de uso disponibles.
  • Gemma 2 9B

¿Cómo funciona el function calling?

1. Declaración de funciones: El proceso comienza definiendo bloques de código reutilizables conocidos como funciones, junto con descripciones de sus capacidades, entradas y salidas.
2. Envío de prompt: El usuario envía un prompt al LLM junto con un conjunto de declaraciones de funciones. Esto informa al modelo sobre las herramientas disponibles.
3. Análisis del modelo: El LLM analiza el prompt y determina si necesita invocar alguna de las funciones proporcionadas para cumplir con la solicitud.
4. Salida estructurada: Si se necesita una llamada a función, el LLM genera una salida estructurada en formato JSON que incluye el nombre de la función y los valores para sus parámetros.
5. Invocación de función: La aplicación o sistema utiliza esta salida estructurada para llamar a la función especificada, pasando los parámetros.
6. Ejecución de función: El servicio externo o API ejecuta la función utilizando los parámetros proporcionados.
7. Respuesta de salida: El servicio externo envía una confirmación o resultado de vuelta a la IA.
8. Respuesta del modelo: El LLM utiliza esta salida para generar una respuesta en lenguaje natural para el usuario o para su posterior procesamiento.

• Ten en cuenta que el modelo no llama directamente a la función; más bien, su salida estructurada es utilizada por un programa externo para hacerlo.

https://www.youtube.com/watch?v=Qor2VZoBib0

Function calling vs. Modo JSON

Beneficios del function calling

• Mayor eficiencia: Llamar a funciones directamente reduce los tiempos de procesamiento y la latencia, algo crucial para aplicaciones que requieren acción inmediata.
• Mayor flexibilidad: Los desarrolladores pueden actualizar o modificar funciones fácilmente sin tener que rehacer aplicaciones completas, permitiendo ajustes más rápidos a nuevos requisitos.
• Escalabilidad: Facilita la escalabilidad al permitir añadir nuevas funciones sin cambios extensos en la infraestructura existente.
• Interacciones personalizadas: Permite experiencias de usuario personalizadas; por ejemplo, acceder al calendario de un usuario para sugerir horarios de reuniones que no entren en conflicto con citas existentes.
• Puente entre la IA y acciones del mundo real: Permite a la IA realizar tareas prácticas como enviar correos electrónicos o mensajes de texto en nombre de los usuarios.
• Agentes conversacionales complejos: Puede crear chatbots sofisticados que respondan preguntas complejas utilizando APIs externas y bases de conocimiento para obtener respuestas relevantes.

Aplicaciones prácticas del function calling

• Agentes conversacionales: Utilizado en chatbots avanzados que emplean APIs externas para obtener información actualizada.
• Comprensión del lenguaje natural: Extrae datos estructurados de texto para tareas como reconocimiento de entidades y análisis de sentimiento.
• Integración de API: Permite a los LLMs integrarse con APIs externas para obtener datos o realizar acciones basadas en la entrada del usuario.
• Asistencia financiera: Construye asesores financieros de IA que acceden a datos financieros en tiempo real y brindan asesoramiento personalizado.
• Automatización de tickets de soporte: Automatiza la asignación de tickets de soporte procesando tickets mediante reglas sensibles al contexto.
• Recuperación de conocimiento: Ayuda a recuperar información de bases de conocimiento creando funciones que resuman artículos académicos para responder preguntas y proporcionar citas.
• Aplicaciones multimodales: Activa funciones basadas en imágenes, videos, audio y PDFs.

Cómo usar el function calling de Llama 3.3 70B a través de Novita AI

Paso 1: Obtén la clave API e instálala

Ingresa a la página “Key Management” y copia la API key como se indica en la imagen.

Puedes encontrar la página “Model Library” de Novita AI. Instala la API de Novita AI usando el gestor de paquetes específico de tu lenguaje de programación.

Al registrarte, Novita AI proporciona un crédito de $0.5 para que empieces.

Si los créditos gratuitos se agotan, puedes pagar para seguir usándolo.

Paso 2: Usa Langchain para implementar el function calling

Crearemos una aplicación matemática simple que pueda realizar operaciones de suma y multiplicación.

💡 Aunque esta guía usa LangChain por conveniencia, implementar el function calling no requiere ningún framework específico. La clave está en diseñar los prompts adecuados para que el modelo entienda e invoque correctamente las funciones. LangChain se usa aquí simplemente para simplificar la implementación.

Requisitos previos

Primero, instala los paquetes necesarios:

pip install langchain-openai python-dotenv

Configuración del entorno

Crea un archivo .env en la raíz de tu proyecto y añade tu clave de API de Novita AI:

NOVITA_API_KEY=tu_clave_api_aqui

Pasos de implementación

1. Define las herramientas

Primero, creemos dos herramientas matemáticas simples usando el decorador @tool de LangChain:

from langchain_core.tools import tool

@tool
def multiply(x: float, y: float) -> float:
    """Multiply two numbers together."""
    return x * y

@tool
def add(x: int, y: int) -> int:
    """Add two numbers."""
    return x + y

tools = [multiply, add]

2. Crea la función de ejecución de herramientas

A continuación, implementa una función para ejecutar las herramientas:

from typing import Any, Dict, Optional, TypedDict
from langchain_core.runnables import RunnableConfig

class ToolCallRequest(TypedDict):
    name: str
    arguments: Dict[str, Any]

def invoke_tool(
    tool_call_request: ToolCallRequest, 
    config: Optional[RunnableConfig] = None
):
    """Execute the specified tool with given arguments."""
    tool_name_to_tool = {tool.name: tool for tool in tools}
    name = tool_call_request["name"]
    requested_tool = tool_name_to_tool[name]
    return requested_tool.invoke(tool_call_request["arguments"], config=config)

3. Configura el pipeline de LangChain

Crea una cadena que use el LLM de Novita AI para seleccionar y preparar las llamadas a herramientas:

from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import render_text_description

def create_chain():
    """Create a chain that uses the specified LLM model to select and prepare tool calls."""
    model = ChatOpenAI(
        model="meta-llama/llama-3.3-70b-instruct",
        api_key=os.getenv("NOVITA_API_KEY"),
        base_url="https://api.novita.ai/v3/openai",
    )
    
    rendered_tools = render_text_description(tools)
    system_prompt = f"""\
    You are an assistant that has access to the following set of tools. 
    Here are the names and descriptions for each tool:

    {rendered_tools}

    Given the user input, return the name and input of the tool to use. 
    Return your response as a JSON blob with 'name' and 'arguments' keys.

    The `arguments` should be a dictionary, with keys corresponding 
    to the argument names and the values corresponding to the requested values.
    """

    prompt = ChatPromptTemplate.from_messages(
        [("system", system_prompt), ("user", "{input}")]
    )

    return prompt | model | JsonOutputParser()

4. Crea la función principal de procesamiento

Implementa la función principal que procesa consultas matemáticas:

def process_math_query(query: str):
    """Process a mathematical query by using an LLM to select the appropriate tool and execute it."""
    chain = create_chain()
    message = chain.invoke({"input": query})
    result = invoke_tool(message, config=None)
    return message, result

5. Ejemplo de uso

Así es como se usa la implementación:

if __name__ == "__main__":
    message, result = process_math_query(
        "meta-llama/llama-3.3-70b-instruct", 
        "what's 3 plus 1132"
    )
    print(result)  # Output: 1135

En conclusión, el function calling está transformando rápidamente la forma en que los sistemas de IA interactúan con su entorno, permitiendo aplicaciones más prácticas, eficientes y fáciles de usar. Modelos como Llama 3.3 70B están allanando el camino para un acceso más sencillo a esta potente tecnología, abriendo numerosas posibilidades para el desarrollo de IA.

Preguntas frecuentes

¿Qué es el function calling en el contexto de los LLMs?

El function calling es una técnica que permite a los modelos de lenguaje grandes reconocer cuándo una tarea específica requiere una función o herramienta externa y generar datos estructurados para ejecutar esa función.

¿Cuáles son los principales beneficios de usar function calling?

Los beneficios clave incluyen una mayor eficiencia en el procesamiento de tareas, una mayor flexibilidad para que los desarrolladores actualicen funciones fácilmente, escalabilidad para añadir nuevas funcionalidades sin cambios extensos, e interacciones de usuario personalizadas.

¿Qué idiomas admite Llama 3.3?

Inglés, francés, alemán, hindi, italiano, portugués, español y tailandés

Novita AI es una plataforma de IA en la nube que ofrece a los desarrolladores una forma sencilla de implementar modelos de IA usando nuestra API simple, al mismo tiempo que proporciona la nube de GPU asequible y confiable para construir y escalar.

Lectura recomendada

• Cómo acceder a Llama 3.3 70b de forma local o mediante API: Una guía completa
• Revelando los secretos del modelo multilingüe Llama 3.3
• Llama 3.3 70B: Características, guía de acceso y comparación de modelos