Khuram Youraj

Posted on Jul 17

Getting Started with Kimi K3: API Setup, Code Examples, and First Impressions

#ai #python #opensource #machinelearning

A practical quickstart guide for developers who want to integrate the world's largest open-source model into their projects today.

Moonshot AI released Kimi K3 on July 16, 2026 — a 2.8-trillion-parameter open-source model with a 1M-token context window that outscores Claude Opus 4.8 on real-world benchmarks. The API is live now, and weights drop July 27.

This guide gets you from zero to a working integration in under 15 minutes.

Prerequisites

Python 3.10+
An API key from Kimi's platform
pip install openai (Kimi K3's API is OpenAI-compatible)

Step 1: Get Your API Key

Cached input: $0.30/MTok
Uncached input: $3.00/MTok
Output: $15.00/MTok

The 90% cache hit rate on coding workloads means most of your input tokens will hit the cheaper tier in practice.

Step 2: Basic Chat Completion

Since Kimi K3 exposes an OpenAI-compatible endpoint, you can use the familiar openai Python package:

from openai import OpenAI

client = OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.kimi.ai/v1"
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to parse nested JSON with error handling."}
    ],
    temperature=0.7,
    max_tokens=2048
)

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

The response quality on coding tasks is immediately noticeable. K3 scored 88.3 on Terminal-Bench 2.1 and leads all models on SWE Marathon (42.0) and Program Bench (77.8).

Step 3: Using the 1M Context Window

The 1M-token context window is K3's killer feature for real-world development. Here's how to feed an entire codebase for analysis:

import os
from pathlib import Path

def collect_source_files(directory, extensions=(".py", ".ts", ".js")):
    files_content = []
    for path in Path(directory).rglob("*"):
        if path.suffix in extensions and path.is_file():
            content = path.read_text(errors="ignore")
            files_content.append(f"### {path.relative_to(directory)}\n```
{% endraw %}
\n{content}\n
{% raw %}
```")
    return "\n\n".join(files_content)

codebase = collect_source_files("./my-project")

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "Analyze this codebase for security vulnerabilities and performance issues."},
        {"role": "user", "content": codebase}
    ],
    max_tokens=4096
)

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

In my testing, K3 handled a ~400-file TypeScript project (~180K tokens) without degradation in output quality. The Mooncake disaggregated inference infrastructure keeps latency reasonable even at high token counts.

Step 4: Multimodal Input (Vision)

K3 has native vision capabilities — no separate model needed:

import base64

def encode_image(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

image_data = encode_image("screenshot.png")

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What UI issues do you see in this screenshot? Suggest CSS fixes."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}}
            ]
        }
    ],
    max_tokens=2048
)

K3 scored 81.6 on MMMU-Pro and 94.3 on MathVision, so visual understanding is genuinely strong — not a bolted-on afterthought.

Step 5: Streaming Responses

For real-time applications, use streaming:

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Explain the difference between KDA and standard attention in Kimi K3's architecture."}
    ],
    stream=True
)

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

First Impressions

After a few days of testing, here's what stands out:

Coding is where K3 shines brightest. It consistently generates cleaner, more idiomatic code than I expected from a first release. The always-on reasoning mode means it doesn't just pattern-match — it thinks through edge cases.

The context window is real. I've been burned by models that advertise large context windows but degrade past 32K tokens. K3 maintains coherence and recall at 200K+ tokens in my tests.

Latency is acceptable, not great. For a 2.8T model, response times are reasonable, but you'll notice the difference compared to smaller models. Streaming helps mask this in user-facing applications.

One quirk: K3 can be overly proactive — it sometimes adds features or refactors you didn't ask for. Specific, constrained prompts work better than open-ended instructions.

What's Next

Weights drop July 27, which means self-hosted deployment is around the corner. If you're planning to run K3 on your own infrastructure, the MXFP4 quantization-aware training means you won't lose quality from post-training quantization — it's baked in from the SFT stage.

For a deeper look at the architecture behind these benchmark numbers, check out the deep dive on Hashnode. And for the bigger picture on what K3 means for the industry, the news brief on Telegraph has the quick summary.

For the full technical breakdown, benchmark tables, and deployment guidance, see our comprehensive Kimi K3 open-source guide.

Happy building.

DEV Community