Kimi K2.5 OpenRouter Integration: Easy API Access & Universal Integration

from openai import OpenAI

# Initialize with OpenRouter
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="YOUR_OPENROUTER_API_KEY"
)

# Make a request to Kimi K2.5
response = client.chat.completions.create(
    model="moonshotai/kimi-k2.5",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain quantum computing in simple terms."}
    ]
)

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

import openai

client = openai.OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="$OPENROUTER_API_KEY"
)

completion = client.chat.completions.create(
    model="moonshotai/kimi-k2.5",
    messages=[
        {"role": "user", "content": "Write a Python function to calculate fibonacci numbers."}
    ],
    extra_headers={
        "HTTP-Referer": "YOUR_SITE_URL",
        "X-Title": "YOUR_APP_NAME"
    }
)

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

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://openrouter.ai/api/v1',
  apiKey: process.env.OPENROUTER_API_KEY,
  defaultHeaders: {
    'HTTP-Referer': 'YOUR_SITE_URL',
    'X-Title': 'YOUR_APP_NAME'
  }
});

async function getCompletion() {
  const completion = await openai.chat.completions.create({
    model: 'moonshotai/kimi-k2.5',
    messages: [
      { role: 'user', content: 'Hello!' }
    ]
  });
  
  console.log(completion.choices[0].message.content);
}

getCompletion();

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "HTTP-Referer: YOUR_SITE_URL" \
  -H "X-Title: YOUR_APP_NAME" \
  -d '{
    "model": "moonshotai/kimi-k2.5",
    "messages": [
      {"role": "user", "content": "What is the meaning of life?"}
    ]
  }'

# Automatic fallback configuration
response = client.chat.completions.create(
    model="moonshotai/kimi-k2.5",
    messages=messages,
    extra_body={
        "models": ["moonshotai/kimi-k2.5", "openai/gpt-4o"],
        "route": "fallback"
    }
)

# Streaming with Kimi K2.5 on OpenRouter
stream = client.chat.completions.create(
    model="moonshotai/kimi-k2.5",
    messages=[{"role": "user", "content": "Tell me a story."}],
    stream=True
)

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="moonshotai/kimi-k2.5",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools
)

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="moonshotai/kimi-k2.5",
    base_url="https://openrouter.ai/api/v1",
    api_key="YOUR_OPENROUTER_API_KEY",
    model_kwargs={
        "headers": {
            "HTTP-Referer": "YOUR_SITE_URL",
            "X-Title": "YOUR_APP_NAME"
        }
    }
)

response = llm.invoke("Explain machine learning.")

from llama_index.llms.openai import OpenAI

llm = OpenAI(
    model="moonshotai/kimi-k2.5",
    api_base="https://openrouter.ai/api/v1",
    api_key="YOUR_OPENROUTER_API_KEY",
    additional_kwargs={
        "headers": {
            "HTTP-Referer": "YOUR_SITE_URL",
            "X-Title": "YOUR_APP_NAME"
        }
    }
)

# Enable reasoning controls
response = client.chat.completions.create(
    model="moonshotai/kimi-k2.5",
    messages=messages,
    reasoning={"max_tokens": 4000},
    include_reasoning=True
)

import time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="YOUR_KEY"
)

def robust_completion(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="moonshotai/kimi-k2.5",
                messages=messages
            )
        except RateLimitError:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
            else:
                raise

# Compare responses across models
models = [
    "moonshotai/kimi-k2.5",
    "openai/gpt-4o",
    "anthropic/claude-3.5-sonnet"
]

for model in models:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    print(f"{model}: {response.choices[0].message.content}")

# Route simple queries to cheaper models
def smart_route(prompt_complexity):
    if prompt_complexity == "simple":
        return "moonshotai/kimi-k2.5"  # Most cost-effective
    elif prompt_complexity == "complex":
        return "moonshotai/kimi-k2.5"  # Still best value
    else:
        return "moonshotai/kimi-k2.5"  # Default to Kimi