import openai

# Direct Moonshot API
client = openai.OpenAI(
 api_key="your-moonshot-key",
 base_url="https://api.moonshot.cn/v1"
)

# Or via Crazyrouter (50% cheaper)
client = openai.OpenAI(
 api_key="sk-cr-your-key",
 base_url="https://crazyrouter.com/v1"
)

# Standard completion
response = client.chat.completions.create(
 model="kimi-k2",
 messages=[
 {"role": "system", "content": "You are a senior software architect."},
 {"role": "user", "content": "Design a rate limiting system for a "
 "multi-tenant API gateway. Consider distributed state, fairness, "
 "and burst handling."}
 ],
 max_tokens=4096,
 temperature=0.7
)

print(response.choices[0].message.content)
print(f"Tokens: {response.usage.prompt_tokens} in / "
 f"{response.usage.completion_tokens} out")

# Thinking mode for complex problems
response = client.chat.completions.create(
 model="kimi-k2-thinking",
 messages=[
 {"role": "user", "content": """
 A company has 3 factories and 4 warehouses. 
 Transportation costs per unit:
 Factory A → W1: $4, W2: $8, W3: $1, W4: $5
 Factory B → W1: $6, W2: $3, W3: $7, W4: $2
 Factory C → W1: $3, W2: $5, W3: $4, W4: $6
 
 Supply: A=300, B=400, C=300
 Demand: W1=250, W2=350, W3=200, W4=200
 
 Find the optimal transportation plan that minimizes total cost.
 Show your work step by step.
 """}
 ],
 max_tokens=8192
)

# Thinking mode shows reasoning chain
print(response.choices[0].message.content)

import json

tools = [
 {
 "type": "function",
 "function": {
 "name": "search_database",
 "description": "Search the product database",
 "parameters": {
 "type": "object",
 "properties": {
 "query": {"type": "string", "description": "Search query"},
 "category": {"type": "string", "enum": ["electronics", "clothing", "food"]},
 "max_price": {"type": "number", "description": "Maximum price filter"}
 },
 "required": ["query"]
 }
 }
 },
 {
 "type": "function",
 "function": {
 "name": "get_weather",
 "description": "Get current weather for a location",
 "parameters": {
 "type": "object",
 "properties": {
 "location": {"type": "string"},
 "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
 },
 "required": ["location"]
 }
 }
 }
]

response = client.chat.completions.create(
 model="kimi-k2",
 messages=[
 {"role": "user", "content": "Find me wireless headphones under $100 "
 "and check if it's good weather for a walk in Tokyo"}
 ],
 tools=tools,
 tool_choice="auto"
)

# Kimi K2 will call both tools in parallel
for tool_call in response.choices[0].message.tool_calls:
 print(f"Function: {tool_call.function.name}")
 print(f"Args: {tool_call.function.arguments}")

const OpenAI = require('openai');

const client = new OpenAI({
 apiKey: 'sk-cr-your-key',
 baseURL: 'https://crazyrouter.com/v1'
});

async function analyzeCode(code) {
 const response = await client.chat.completions.create({
 model: 'kimi-k2',
 messages: [
 { role: 'system', content: 'You are a code review expert. Find bugs, ' +
 'security issues, and performance problems.' },
 { role: 'user', content: `Review this code:\n\n${code}` }
 ],
 max_tokens: 4096,
 temperature: 0.3
 });
 
 return response.choices[0].message.content;
}

// Usage
const review = await analyzeCode(fs.readFileSync('app.py', 'utf8'));
console.log(review);

curl https://crazyrouter.com/v1/chat/completions \
 -H "Authorization: Bearer sk-cr-your-key" \
 -H "Content-Type: application/json" \
 -d '{
 "model": "kimi-k2",
 "messages": [
 {"role": "user", "content": "Explain the CAP theorem with real-world examples for each trade-off"}
 ],
 "max_tokens": 2048
 }'

def smart_route(query: str, complexity: str = "auto"):
 """Route to standard or thinking based on complexity"""
 
 if complexity == "auto":
 # Simple heuristic: use thinking for math/logic keywords
 thinking_keywords = ["prove", "calculate", "optimize", "solve",
 "step by step", "reasoning", "analyze"]
 needs_thinking = any(kw in query.lower() for kw in thinking_keywords)
 else:
 needs_thinking = complexity == "high"
 
 model = "kimi-k2-thinking" if needs_thinking else "kimi-k2"
 
 return client.chat.completions.create(
 model=model,
 messages=[{"role": "user", "content": query}],
 max_tokens=4096
 )

# Stuff the entire document into context (free up to 128K)
with open("annual_report.txt") as f:
 document = f.read() # ~80K tokens

response = client.chat.completions.create(
 model="kimi-k2",
 messages=[
 {"role": "system", "content": "Analyze this annual report."},
 {"role": "user", "content": f"{document}\n\nWhat are the top 3 risks?"}
 ]
)

import hashlib
import json

cache = {}

def cached_completion(messages, model="kimi-k2", **kwargs):
 """Simple in-memory cache for repeated queries"""
 cache_key = hashlib.md5(
 json.dumps(messages, sort_keys=True).encode()
 ).hexdigest()
 
 if cache_key in cache:
 return cache[cache_key]
 
 response = client.chat.completions.create(
 model=model, messages=messages, **kwargs
 )
 cache[cache_key] = response
 return response

# One API key, automatic routing and fallback
client = openai.OpenAI(
 api_key="sk-cr-your-key",
 base_url="https://crazyrouter.com/v1"
)