Blog

Cómo Usar la API Kimi K2.5

Ashley Innocent

Ashley Innocent

27 January 2026

Cómo Usar la API Kimi K2.5

Los desarrolladores buscan cada vez más APIs robustas que manejen entradas multimodales complejas y entreguen salidas inteligentes. La API Kimi K2.5 se destaca como una herramienta versátil de Moonshot AI, que permite a las aplicaciones procesar texto, imágenes y videos con capacidades de razonamiento avanzadas. Esta API le permite construir soluciones sofisticadas impulsadas por IA, desde la depuración visual en código hasta la orquestación de enjambres de agentes para la ejecución paralela de tareas.

💡
¿Quieres seguir el ejemplo? Descarga Apidog para probar visualmente tus llamadas a la API Kimi K2.5. Apidog te permite configurar solicitudes, inspeccionar respuestas, depurar problemas de autenticación y generar código listo para producción, todo sin escribir código repetitivo. Es la forma más rápida de experimentar con las capacidades de K2.5 antes de comprometerte con el código.
botón

¿Qué es Kimi K2.5?

Kimi K2.5 representa el modelo multimodal de código abierto más avanzado de Moonshot AI, construido a través de un preentrenamiento continuo en aproximadamente 15 billones de tokens visuales y de texto mixtos sobre la arquitectura Kimi-K2-Base. A diferencia de su predecesor, K2.5 integra a la perfección la comprensión de la visión y el lenguaje con capacidades agénticas avanzadas, lo que lo hace particularmente potente para los desarrolladores que construyen aplicaciones impulsadas por IA.

El modelo introduce varias características innovadoras que lo distinguen de otras APIs de IA. Su multimodalidad nativa significa que fue preentrenado con tokens de visión-lenguaje desde cero, en lugar de tener capacidades de visión añadidas como una ocurrencia tardía. Este enfoque da como resultado un rendimiento superior en conocimiento visual, razonamiento transmodal y uso de herramientas agénticas basadas en entradas visuales.

Por qué Kimi K2.5 es importante para los desarrolladores:

Características y Capacidades Clave

Inteligencia Multimodal Nativa

K2.5 se destaca en el conocimiento visual, el razonamiento transmodal y el uso de herramientas agénticas basadas en entradas visuales. Esto no es solo reconocimiento de imágenes, es una comprensión profunda del contexto visual que puede informar la toma de decisiones complejas.

Codificación con Visión

Una de las capacidades destacadas de K2.5 es la generación de código a partir de especificaciones visuales. Apúntalo a un prototipo de diseño de interfaz de usuario y podrá producir código frontend funcional. Muéstrale un flujo de trabajo de video y podrá orquestar herramientas para el procesamiento visual de datos. Esto lo hace particularmente valioso para:

Arquitectura de Enjambre de Agentes

K2.5 transita de la escalabilidad de un solo agente a un esquema de ejecución coordinado y autodirigido similar a un enjambre. Cuando se enfrenta a tareas complejas, puede:

  1. Descomponer el problema en subtareas paralelas
  2. Instanciar dinámicamente agentes específicos del dominio
  3. Coordinar la ejecución entre múltiples agentes
  4. Sintetizar resultados en salidas coherentes

Esta arquitectura permite a K2.5 manejar tareas que abrumarían a los sistemas de un solo agente, como la refactorización integral de código, la generación de documentación de múltiples archivos o pipelines complejos de análisis de datos.

Rendimiento en Benchmarks

Primeros Pasos con la API Kimi K2.5

Paso 1: Crea tu Cuenta de Moonshot AI

Visita platform.moonshot.ai y regístrate para obtener una cuenta. El proceso de registro es sencillo:

  1. Haz clic en "Sign Up" (Registrarse) o "Register" (Registrar)
  2. Proporciona tu correo electrónico y crea una contraseña
  3. Verifica tu dirección de correo electrónico
  4. Completa cualquier información de perfil requerida

Paso 2: Genera tu Clave de API

Una vez que hayas iniciado sesión:

  1. Navega a la sección de Claves de API en tu panel de control
  2. Haz clic en "Create New API Key" (Crear Nueva Clave de API)
  3. Dale a tu clave un nombre descriptivo (ej. "kimi-k2-5-development")
  4. Copia y guarda de forma segura tu clave de API, no la volverás a ver

Consejo de seguridad: Nunca subas claves de API al control de versiones. Utiliza variables de entorno o un gestor de secretos.

Paso 3: Configura tu Entorno

Para Python:

pip install --upgrade 'openai>=1.0'

Para Node.js:

npm install openai@latest

Paso 4: Configura tu Clave de API

Establece tu clave de API como una variable de entorno:

macOS/Linux:

export MOONSHOT_API_KEY="your-api-key-here"

Windows (PowerShell):

[System.Environment]::SetEnvironmentVariable("MOONSHOT_API_KEY", "your-api-key-here", "User")

Windows (Símbolo del sistema):

setx MOONSHOT_API_KEY "your-api-key-here"

Ejemplos de Código Python

Finalización Básica del Chat

Aquí tienes un ejemplo sencillo para empezar con Kimi K2.5:

import os
from openai import OpenAI

# Inicializa el cliente con el endpoint de Moonshot AI
client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Crea una finalización de chat
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "You are Kimi, an AI assistant developed by Moonshot AI. You are helpful, harmless, and honest."
        },
        {
            "role": "user",
            "content": "Explain the concept of mixture-of-experts architecture in neural networks."
        }
    ],
    temperature=0.6,
    max_tokens=2048,
)

print(response.choices[0].message.content)

Respuestas en Streaming

Para aplicaciones en tiempo real, usa el streaming para mostrar las respuestas a medida que se generan:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Transmite la respuesta
stream = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "Write a Python function to implement binary search."}
    ],
    stream=True,
    temperature=0.3,
)

# Procesa el stream
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Conversación Multi-Turno

Mantén el contexto a través de múltiples intercambios:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

conversation_history = [
    {"role": "system", "content": "You are a helpful coding assistant."}
]

def chat(user_message):
    conversation_history.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=conversation_history,
        temperature=0.6,
    )

    assistant_message = response.choices[0].message.content
    conversation_history.append({"role": "assistant", "content": assistant_message})

    return assistant_message

# Ejemplo de conversación
print(chat("How do I create a REST API in Python?"))
print(chat("Can you show me how to add authentication to that?"))
print(chat("What about rate limiting?"))

Implementación Asíncrona

Para aplicaciones de alto rendimiento, usa async/await:

import os
import asyncio
from openai import AsyncOpenAI

async def main():
    client = AsyncOpenAI(
        api_key=os.environ.get("MOONSHOT_API_KEY"),
        base_url="https://api.moonshot.ai/v1",
    )

    # Ejecuta múltiples solicitudes concurrentemente
    tasks = [
        client.chat.completions.create(
            model="kimi-k2.5-preview",
            messages=[{"role": "user", "content": f"What is {topic}?"}],
        )
        for topic in ["REST API", "GraphQL", "gRPC"]
    ]

    responses = await asyncio.gather(*tasks)

    for response in responses:
        print(response.choices[0].message.content[:200])
        print("-" * 50)

asyncio.run(main())

Ejemplos de JavaScript/Node.js

Finalización Básica del Chat

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: 'https://api.moonshot.ai/v1',
});

async function chat(userMessage) {
  const response = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [
      {
        role: 'system',
        content: 'You are Kimi, a helpful AI assistant.',
      },
      {
        role: 'user',
        content: userMessage,
      },
    ],
    temperature: 0.6,
  });

  return response.choices[0].message.content;
}

// Uso
const answer = await chat('How do I implement a binary search tree in JavaScript?');
console.log(answer);

Streaming con Node.js

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: 'https://api.moonshot.ai/v1',
});

async function streamChat(userMessage) {
  const stream = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [{ role: 'user', content: userMessage }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }
}

await streamChat('Explain microservices architecture');

Uso de la API Fetch (Funciones de Navegador/Edge)

async function callKimiAPI(prompt) {
  const response = await fetch('https://api.moonshot.ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.MOONSHOT_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'kimi-k2.5-preview',
      messages: [{ role: 'user', content: prompt }],
      temperature: 0.6,
    }),
  });

  const data = await response.json();
  return data.choices[0].message.content;
}

// Uso
const result = await callKimiAPI('What are the best practices for API design?');
console.log(result);

Probando la API Kimi K2.5 con Apidog

Probar las APIs de IA de manera efectiva requiere comprender las estructuras de solicitud/respuesta, manejar el streaming, gestionar la autenticación y depurar problemas. Apidog proporciona una solución integral para el desarrollo de APIs que hace que trabajar con Kimi K2.5 sea sencillo.

Configuración de Kimi K2.5 en Apidog

Paso 1: Crear un Nuevo Proyecto

  1. Abre Apidog y crea un nuevo proyecto llamado "Integración Kimi K2.5"
  2. Esto organiza todos tus endpoints relacionados con Kimi en un solo lugar

Paso 2: Configurar Variables de Entorno

  1. Navega a Configuración de Entorno
  2. Añade una nueva variable de entorno:

Paso 3: Crear el Endpoint de Finalizaciones de Chat

  1. Añade una nueva solicitud POST
  2. URL: https://api.moonshot.ai/v1/chat/completions
  3. Cabeceras:

Paso 4: Configurar el Cuerpo de la Solicitud

{
  "model": "kimi-k2.5-preview",
  "messages": [
    {
      "role": "system",
      "content": "Eres un asistente de IA útil."
    },
    {
      "role": "user",
      "content": "Hola, ¿cómo puedes ayudarme hoy?"
    }
  ],
  "temperature": 0.6,
  "max_tokens": 2048,
  "stream": false
}

Depuración con Apidog

La interfaz visual de Apidog te ayuda a:

Creación de Pruebas Automatizadas

Con el ejecutor de pruebas de Apidog, puedes verificar tu integración de Kimi K2.5:

// Script de prueba post-respuesta en Apidog
pm.test("El estado de la respuesta es 200", function () {
    pm.response.to.have.status(200);
});

pm.test("La respuesta contiene opciones", function () {
    const response = pm.response.json();
    pm.expect(response.choices).to.be.an('array');
    pm.expect(response.choices.length).to.be.greaterThan(0);
});

pm.test("El contenido de la respuesta no está vacío", function () {
    const response = pm.response.json();
    pm.expect(response.choices[0].message.content).to.not.be.empty;
});

Llamada a Herramientas y Capacidades de Agente

Una de las características más potentes de Kimi K2.5 es su capacidad para llamar a herramientas externas. Esto permite construir agentes de IA sofisticados que pueden interactuar con sistemas externos.

Definición de Herramientas

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Define las herramientas disponibles
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtiene el clima actual para una ubicación",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Ciudad y país, ej., 'Londres, Reino Unido'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Unidad de temperatura"
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Busca información en una base de datos",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Consulta de búsqueda"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "Número máximo de resultados"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# Realiza una solicitud con herramientas
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "What's the weather like in Tokyo?"}
    ],
    tools=tools,
    tool_choice="auto",
)

# Maneja las llamadas a herramientas
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        print(f"Tool: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")

Ejecutando Llamadas a Herramientas

import json

def execute_tool_call(tool_call):
    """Ejecuta una llamada a herramienta y devuelve el resultado."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "get_weather":
        # Simula una llamada a la API del clima
        return json.dumps({
            "location": args["location"],
            "temperature": 22,
            "unit": args.get("unit", "celsius"),
            "condition": "sunny"
        })
    elif name == "search_database":
        # Simula una búsqueda en la base de datos
        return json.dumps({
            "results": [
                {"id": 1, "title": "Result 1"},
                {"id": 2, "title": "Result 2"}
            ]
        })

    return json.dumps({"error": "Unknown tool"})

# Completa la conversación con los resultados de la herramienta
messages = [
    {"role": "user", "content": "What's the weather in Tokyo?"}
]

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=messages,
    tools=tools,
)

if response.choices[0].message.tool_calls:
    # Añade el mensaje del asistente con las llamadas a herramientas
    messages.append(response.choices[0].message)

    # Ejecuta cada herramienta y añade los resultados
    for tool_call in response.choices[0].message.tool_calls:
        result = execute_tool_call(tool_call)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

    # Obtiene la respuesta final
    final_response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=messages,
        tools=tools,
    )

    print(final_response.choices[0].message.content)

Características de Visión y Multimodales

Las capacidades multimodales nativas de K2.5 permiten procesar imágenes junto con texto:

import os
import base64
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

def encode_image(image_path):
    """Codifica la imagen a base64."""
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Analiza una imagen
image_base64 = encode_image("screenshot.png")

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Analiza este diseño de UI y sugiere mejoras."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_base64}"
                    }
                }
            ]
        }
    ],
    max_tokens=2048,
)

print(response.choices[0].message.content)

Generación de Código a partir de Entrada Visual

# Genera código a partir de un wireframe
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "Eres un desarrollador frontend experto. Genera código limpio y listo para producción."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Convierte este wireframe en un componente React con estilos Tailwind CSS."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{encode_image('wireframe.png')}"
                    }
                }
            ]
        }
    ],
    temperature=0.3,
)

print(response.choices[0].message.content)

Precios y Límites de Tasa

Puntos clave:

Mejores Prácticas y Consejos

Optimizar el Uso de Tokens

# Usa los prompts del sistema de manera eficiente
system_prompt = """Eres un asistente técnico conciso.
Reglas: 1) Sé breve 2) Usa bloques de código 3) Omite las formalidades"""

# Habilita el almacenamiento en caché para contextos repetidos
# Moonshot almacena automáticamente en caché prompts similares

Configuración de Temperatura

Manejo de Errores

from openai import OpenAI, APIError, RateLimitError

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

def safe_chat(message, retries=3):
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model="kimi-k2.5-preview",
                messages=[{"role": "user", "content": message}],
            )
            return response.choices[0].message.content
        except RateLimitError:
            if attempt < retries - 1:
                time.sleep(2 ** attempt)  # Retroceso exponencial
            else:
                raise
        except APIError as e:
            print(f"Error de API: {e}")
            raise

result = safe_chat("Hello, Kimi!")

Resolución de Problemas Comunes

Errores de Autenticación

Problema: Error 401 No autorizado

Soluciones:

  1. Verifica que tu clave de API sea correcta
  2. Comprueba que la clave no haya expirado
  3. Asegúrate de que el formato de la cabecera Authorization sea correcto: Bearer TU_CLAVE

Límite de Tasa

Problema: 429 Demasiadas Solicitudes

Soluciones:

  1. Implementa retroceso exponencial
  2. Actualiza tu nivel añadiendo fondos
  3. Monitoriza las cabeceras X-RateLimit-Remaining

Longitud de Contexto Excedida

Problema: La solicitud excede el límite de 256K tokens

Soluciones:

  1. Resume conversaciones largas
  2. Usa un enfoque de ventana deslizante
  3. Divide en múltiples solicitudes

Problemas de Tiempo de Espera

Problema: Las solicitudes agotan el tiempo de espera

Soluciones:

  1. Usa streaming para respuestas largas
  2. Aumenta la configuración de tiempo de espera del cliente
  3. Divide los prompts complejos en tareas más pequeñas

¿Listo para construir con Kimi K2.5? Descarga Apidog para optimizar tu flujo de trabajo de desarrollo de API con pruebas visuales, documentación automática y funciones de colaboración en equipo que hacen que la integración de APIs de IA sea más rápida y fiable.

botón

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar