from openai import OpenAI

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

response = client.chat.completions.create(
 model="kimi-k2-thinking",
 messages=[
 {
 "role": "system",
 "content": "You are a senior software architect. Think step by step."
 },
 {
 "role": "user",
 "content": """Design a distributed rate limiter that:
1. Handles 100K requests/second across 50 nodes
2. Supports sliding window algorithm
3. Has <5ms p99 latency
4. Gracefully degrades if Redis is unavailable

Provide the architecture, data structures, and Go implementation."""
 }
 ],
 temperature=0.1, # Low temp for reasoning tasks
 max_tokens=8192
)

print(response.choices[0].message.content)
# Includes detailed reasoning + implementation

from openai import OpenAI

client = OpenAI(
 api_key="your-crazyrouter-key",
 base_url="https://crazyrouter.com/v1"
)

# Same model, lower price, automatic fallback
response = client.chat.completions.create(
 model="kimi-k2-thinking",
 messages=[{
 "role": "user",
 "content": "Prove that there are infinitely many primes of the form 4k+3."
 }],
 temperature=0.0,
 max_tokens=4096
)

# Stream the response including reasoning process
stream = client.chat.completions.create(
 model="kimi-k2-thinking",
 messages=[{
 "role": "user",
 "content": "Find all bugs in this code and explain your reasoning:\n\n"
 "```python\n"
 "def merge_sorted(a, b):\n"
 " result = []\n"
 " i = j = 0\n"
 " while i < len(a) and j < len(b):\n"
 " if a[i] <= b[j]:\n"
 " result.append(a[i])\n"
 " i += 1\n"
 " else:\n"
 " result.append(b[j])\n"
 " j += 1\n"
 " return result\n"
 "```"
 }],
 stream=True,
 stream_options={"include_usage": True}
)

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

import OpenAI from 'openai';

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

async function solveWithReasoning(problem) {
 const response = await client.chat.completions.create({
 model: 'kimi-k2-thinking',
 messages: [
 {
 role: 'system',
 content: 'Solve problems step by step. Show your reasoning clearly.'
 },
 { role: 'user', content: problem }
 ],
 temperature: 0.1,
 max_tokens: 8192,
 });

 return {
 answer: response.choices[0].message.content,
 tokens: response.usage,
 };
}

// Example: Complex algorithm design
const result = await solveWithReasoning(
 'Design an algorithm to find the longest increasing subsequence ' +
 'in O(n log n) time. Prove its correctness and analyze space complexity.'
);

def smart_route(query, complexity_score):
 """Route to appropriate model based on task complexity."""
 if complexity_score < 0.3:
 # Simple tasks: use fast, cheap model
 return "gpt-4o-mini"
 elif complexity_score < 0.7:
 # Medium tasks: K2 standard (non-thinking)
 return "kimi-k2"
 else:
 # Complex reasoning: K2 Thinking
 return "kimi-k2-thinking"

# Estimate complexity from query characteristics
def estimate_complexity(query):
 indicators = [
 "prove" in query.lower(),
 "design" in query.lower() and "system" in query.lower(),
 "optimize" in query.lower(),
 len(query) > 500,
 "step by step" in query.lower(),
 any(word in query.lower() for word in ["algorithm", "architecture", "debug"])
 ]
 return sum(indicators) / len(indicators)

# Control reasoning depth with max_tokens
# Shorter max_tokens = less thinking = cheaper

# Quick reasoning (budget mode)
response = client.chat.completions.create(
 model="kimi-k2-thinking",
 messages=[{"role": "user", "content": problem}],
 max_tokens=2048 # Limits thinking depth
)

# Deep reasoning (quality mode)
response = client.chat.completions.create(
 model="kimi-k2-thinking",
 messages=[{"role": "user", "content": problem}],
 max_tokens=16384 # Allows extensive reasoning
)

import hashlib
import json
import redis

r = redis.Redis()

def cached_reasoning(prompt, model="kimi-k2-thinking"):
 # Hash the prompt for cache key
 cache_key = f"reasoning:{hashlib.sha256(prompt.encode()).hexdigest()}"

 # Check cache
 cached = r.get(cache_key)
 if cached:
 return json.loads(cached)

 # Generate fresh reasoning
 response = client.chat.completions.create(
 model=model,
 messages=[{"role": "user", "content": prompt}],
 temperature=0.0 # Deterministic for caching
 )

 result = {
 "content": response.choices[0].message.content,
 "tokens": response.usage.model_dump()
 }

 # Cache for 24 hours
 r.setex(cache_key, 86400, json.dumps(result))
 return result