¡Novita Kimi K2 API ahora soporta Function Calling!

Kimi K2 representa una nueva era de agentes de IA, combinando un rendimiento de vanguardia en dominios especializados con asequibilidad y flexibilidad de código abierto. Con sus 32 mil millones de parámetros activados y 1 billón de parámetros totales, Kimi K2 destaca por sus fortalezas especializadas en STEM, programación y uso de herramientas.

Este artículo explora cómo el function calling mejora las capacidades de agente de Kimi K2, qué implica esta característica y cómo posiciona a Kimi K2 como líder en el futuro de los agentes de IA.

Capacidades de agente de código de Kimi K2

1. Dominio en STEM y programación

   • Kimi K2 alcanza un rendimiento de última generación (SOTA) en benchmarks de STEM y programación, incluyendo LiveCodeBench y OJBench.
   • Puede generar código complejo, depurar problemas y simular algoritmos intrincados con precisión.

2. Experiencia en uso de herramientas

   • Kimi K2 ha sido entrenado en escenarios de uso de herramientas multi-turno en cientos de dominios.
   • Su capacidad para identificar cuándo se necesita una herramienta y ejecutar flujos de trabajo de varios pasos lo convierte en un asistente de programación muy práctico.

3. Aprendizaje por refuerzo para ejecución de tareas

   • Al aprovechar autoevaluaciones basadas en rúbricas y aprendizaje on-policy, Kimi K2 mejora continuamente su juicio y toma de decisiones.

De Kimi

Las capacidades de agente de Kimi K2 dependen del Function Calling

Si bien las fortalezas inherentes de Kimi K2 en programación y uso de herramientas son impresionantes, sus capacidades de agente dependen en gran medida del function calling. Sin esta característica, su capacidad para interactuar con herramientas y sistemas externos se vería severamente limitada.

¿Qué es Function Calling?

Function calling es un mecanismo estructurado que permite a los modelos de lenguaje grandes (LLMs) interactuar con sistemas, herramientas o APIs externas. En lugar de simplemente generar texto, un LLM con soporte de function calling puede analizar las indicaciones del usuario, identificar cuándo se requiere una acción externa y generar llamadas JSON estructuradas para ejecutar funciones específicas.

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

Cómo funciona Function Calling

1. Análisis de la indicación: El LLM interpreta la solicitud del usuario y determina si se necesita una llamada a función.
2. Generación de llamada JSON: Genera un objeto JSON estructurado que contiene el nombre de la función y los parámetros necesarios.
3. Ejecución por sistemas externos: Un sistema externo recibe la llamada JSON, ejecuta la función y devuelve los resultados.
4. Generación de respuesta: El LLM utiliza los datos devueltos para proporcionar una respuesta final al usuario.

Este ciclo puede repetirse para tareas de múltiples pasos o complejas, permitiendo al modelo actuar como un agente dinámico e interactivo.

Por qué Function Calling es esencial

• Transforma el conocimiento en acción: Function calling permite a Kimi K2 pasar de ser un “proveedor de conocimiento” a un “ejecutor de tareas”.
• Interacciones con el mundo real: Habilita a Kimi K2 para interactuar con APIs, bases de datos y sistemas externos, automatizando eficazmente tareas como programación de citas, recuperación de datos y control de IoT.
• Flujos de trabajo multi-paso: Kimi K2 puede encadenar múltiples llamadas a funciones para ejecutar flujos de trabajo complejos, como obtener datos, procesarlos y almacenar resultados.

Function Calling vs SDK

Característica	Function Calling	SDK
Definición	Un mecanismo estructurado para que los LLMs activen funciones o APIs externas.	Un conjunto de herramientas que simplifica la interacción con APIs y sistemas externos.
Propósito	Permite la ejecución directa de tareas generando llamadas a funciones (por ejemplo, JSON).	Proporciona herramientas y bibliotecas preconstruidas para una integración más sencilla con APIs.
Flexibilidad	Altamente dinámico, permitiendo a los modelos interactuar con cualquier función definida.	Limitado a las características y endpoints soportados por el SDK.
Implementación	Requiere definir funciones, esquemas y manejar respuestas manualmente.	Abstracta la lógica de la API, ofreciendo una experiencia plug-and-play.
Caso de uso	Ideal para automatización de tareas multi-paso y toma de decisiones en tiempo real.	Mejor para desarrollo rápido con flujos de trabajo predefinidos.
Esfuerzo del desarrollador	Requiere más configuración para definir y gestionar llamadas a funciones.	Esfuerzo mínimo; simplifica el uso de la API con métodos preconstruidos.

¿Qué se puede lograr con Kimi K2 + Function Calling?

La combinación de las fortalezas de Kimi K2 y las capacidades de function calling desbloquea una amplia gama de aplicaciones del mundo real:

1. Ejecución de tareas del mundo real

• Automatización: Automatiza tareas repetitivas como reservar citas, enviar formularios o generar informes.
• Control de IoT: Interactúa con dispositivos IoT para realizar acciones como ajustar la temperatura ambiente o encender/apagar luces.

2. Acceso a datos en tiempo real

• Actualizaciones dinámicas: Recupera datos en tiempo real (por ejemplo, clima, precios de acciones) mediante llamadas a API.
• Respuestas mejoradas: Integra información en tiempo real en las respuestas, mejorando la precisión y relevancia.

3. Aplicaciones multimodales avanzadas

• Procesamiento de imágenes y video: Activa herramientas externas para tareas como edición de imágenes o recorte de video.
• Integración entre formatos: Procesa entradas de texto, imágenes y audio para realizar tareas complejas.

4. Flujos de trabajo y pipelines complejos

• Encadena múltiples llamadas a funciones para ejecutar pipelines de datos, por ejemplo:
  • Obtener datos → Analizarlos → Almacenar resultados.
• Habilita la integración sin problemas con bases de datos y herramientas de análisis para flujos de trabajo avanzados.

5. Soluciones amigables para desarrolladores

• APIs personalizadas: Los desarrolladores pueden ajustar Kimi K2 para interactuar con APIs y herramientas propietarias.
• Integraciones escalables: Añade fácilmente nuevas funciones para expandir capacidades sin grandes cambios en la infraestructura.

Una demo que muestra Kimi K2 con Function Calling

1. Mi presupuesto total es de $10,000, que debe cubrir todos los gastos incluyendo transporte, alojamiento y entradas. Proporcione un desglose detallado del presupuesto para todo el viaje. Mis criterios principales de evaluación son: conveniencia del transporte, disponibilidad de entradas y calidad de las atracciones locales.

2. Por favor, refiérase a mi presupuesto total mencionado anteriormente.

3. Además de mi presupuesto total especificado anteriormente, busco alojamiento que ofrezca una experiencia local auténtica, por lo que tengo preferencia por Airbnb.

4. Revise mi Google Mail y cree entradas en mi Google Calendar.

Novita Kimi K2 API admite Function Calling

Esta guía demuestra cómo usar Function Calling para recuperar información meteorológica actual para la ubicación especificada por el usuario. Repasaremos un ejemplo completo de código en Python.

Para el formato específico de la API de Function Calling, consulte la Documentación!

¡Prueba Kimi K2 ahora!

• Inicializar el cliente

Primero, debe inicializar el cliente con su clave de API de Novita.

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    # Obtenga la clave de API de Novita AI desde: https://novita.ai/settings/key-management.
    api_key="<YOUR Novita AI API Key>",
)

model = "moonshotai/kimi-k2-instruct"

• Definir la función a llamar

A continuación, defina 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 meteorológicos.
def get_weather(location):
    """Recupera el clima actual para una ubicación dada."""
    print("Llamando a la función get_weather con ubicación: ", location)
    # En una aplicación real, aquí llamaría a una API meteorológica externa.
    # Este es un ejemplo simplificado que devuelve datos fijos.
    return json.dumps({"location": location, "temperature": "60 grados Fahrenheit"})

• Construir la solicitud API con herramientas y mensaje del usuario

Ahora, cree la solicitud API al endpoint de Novita. Esta solicitud incluye el parámetro tools, que define 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, p. 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,
)

# Verifique si la respuesta contiene tool_calls si está en producción.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())

• Salida

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

• 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úrese de que tool_call esté definido desde el paso anterior
if tool_call:
    # Ampliar el historial de la conversación con el mensaje de tool_call 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)
        # Ejecutar la función y obtener la respuesta
        function_response = get_weather(
            location=function_args.get("location"))
        # Añadir la respuesta de la función a los mensajes
        messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "content": function_response,
            }
        )

    # Obtener 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 incluya el parámetro tools aquí.
    )
    print(answer_response.choices[0].message)

• Salida

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

Novita AI ahora ofrece compatibilidad con el SDK de Anthropic

La combinación de Kimi K2 y Claude Code se ha convertido rápidamente en un tema candente en la comunidad de IA, ofreciendo capacidades de agente inigualables para aplicaciones del mundo real. Para hacer esta integración aún más fluida, Novita AI ahora proporciona compatibilidad con el SDK de Anthropic, permitiéndole aprovechar sin esfuerzo el poder de Kimi K2 a través de la interfaz familiar de Claude Code.

¡Puede consultar esta documentación para obtener más detalles!

1. Instalar el SDK de Anthropic

pip install anthropic

2. Inicializar el cliente

Los SDK de Anthropic están diseñados para obtener la clave de API y la URL base de las variables de entorno: ANTHROPIC_API_KEY y ANTHROPIC_BASE_URL. También puede proporcionar los parámetros al cliente de Anthropic al inicializarlo.

Puede ver y gestionar sus claves de API en la página de configuración.

• Usando variables de entorno

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_API_KEY="<YOUR_NOVITA_API_KEY>"

• Establecer los parámetros al inicializar el cliente de Anthropic

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

3. Llamar a la API

import anthropic

# Inicialice el cliente, si ya configuró `ANTHROPIC_BASE_URL` y `ANTHROPIC_API_KEY` 
# en las variables de entorno, puede omitir los parámetros `api_key` y `base_url`.
client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<YOUR_NOVITA_API_KEY>"
)

message = client.messages.create(
    model="moonshotai/kimi-k2-instruct",
    max_tokens=1000,
    temperature=1,
    system="Eres un poeta de clase mundial. Responde solo con poemas cortos.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "¿Por qué el océano es salado?"
                }
            ]
        }
    ]
)

print(message.content)

El soporte de Kimi K2 para function calling lo eleva de un LLM de alto rendimiento a un agente de IA de próxima generación capaz de interactuar con el mundo real y ejecutar tareas. Cuando se combina con su dominio en STEM y programación, esta característica posiciona a Kimi K2 como una solución rentable y especializada para desarrollar sistemas de IA prácticos y dinámicos.

Al cerrar la brecha entre el conocimiento y la acción, Kimi K2 no solo mejora la experiencia del usuario, sino que también democratiza el acceso a capacidades avanzadas de IA. Su naturaleza de código abierto y asequibilidad lo convierten en una fuerza disruptiva en el panorama de la IA, allanando el camino para una innovación y adopción generalizadas.

Preguntas frecuentes

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

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, flexibilidad mejorada para que los desarrolladores actualicen funciones fácilmente, escalabilidad para añadir nuevas funcionalidades sin cambios extensos e interacciones personalizadas con el usuario.

¿Puede Kimi K2 reemplazar modelos propietarios como GPT-4 o Claude?

Kimi K2 no pretende reemplazar modelos de propósito general. En cambio, se centra en ser un agente especializado con fortalezas en STEM, programación y uso de herramientas, complementado por sus capacidades de function calling

Novita AI es la plataforma en la nube integral 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.

Lectura recomendada

• Una guía para acceder a DeepSeek V3: localmente y a través de API
• DeepSeek V3 vs R1: entrenamiento por etapas vs ciclos iterativos de SFT-RL
• Ejecutando DeepSeek V3 localmente: una guía para desarrolladores