Access Kimi K2: Unlock Cheaper Claude Code and MCP Integration, and more！

Kimi K2 has positioned itself as a next-generation AI model with exceptional coding and tool-use capabilities. With its Mixture of Experts (MoE) architecture and advanced training techniques, it promises high performance in agentic tasks like coding, debugging, and tool management. But does it truly deliver on its claim to be a top-tier code agent? Let’s explore its abilities and performance.

Does Kimi K2 Really Change the Future of AI Agents?

kimi k2 Basic Attribute

Category	Details
Basic Info	32 billion activated parameters, 1 trillion total parameters.
	Open
	Mixture of Experts (MoE)
Variants	Foundation model for researchers and builders. Best for fine-tuning and custom solutions.
	Post-trained model for general-purpose chat and agent tasks. Reflex-grade for fast responses without extended thinking.
Capabilities	Text-to-text
	Excels in Chinese and English
Hardware	Disk Space: 1.09 TB for the full model.

kimi k2’s Excellent Agent Ability

• Optimizer: MuonClip Optimizer with advanced instability resolution techniques.
• Agentic Abilities:
  • Tool Use Training:
    • Simulates multi-turn tool-use scenarios with hundreds of domains and thousands of tools.
    • Data filtered by LLM-based evaluators using task-specific rubrics.
  • Reinforcement Learning:
    • Verifiable tasks (e.g., math, coding): Standard reward signals.
    • Non-verifiable tasks (e.g., writing reports): Rubric-based self-assessments.
    • Continuous improvement with on-policy learning for enhanced judgment.

kimi k2’s Performance

Based on the benchmarks, Kimi K2 is a specialized, top-tier model with clear strengths. Its abilities can be grouped into three distinct tiers:

• Tier 1 (Dominant): Math & STEM
  This is Kimi K2’s strongest area. It achieves state-of-the-art (SOTA) performance across the majority of math and science benchmarks (AIME, MATH-500, HMMT, ZebraLogic), indicating a superior reasoning engine.
• Tier 2 (Top-Tier): Coding & Tool Use
  Kimi K2 excels at coding (LiveCodeBench, OJBench) and agentic tasks. Its ability to use tools is particularly impressive, showing a massive lead in the Tau2 telecom benchmark. While highly competitive, it narrowly trails Claude models in some specific agentic coding scenarios (SWE-bench).
• Tier 3 (Competitive): General Knowledge
  In broad knowledge benchmarks like MMLU, Kimi K2 performs well but is generally outmatched by the leading proprietary models (e.g., Claude Opus 4). Its performance in simple Q&A tasks also lags behind competitors like GPT-4.1.

In short: Kimi K2 is a powerhouse in STEM, coding, and tool use, but less dominant in general knowledge.

But the price is the lowest among all compatible models!

Access Kimi K2 via Free Playground

You can access Kimi K2 via the Kimi Chat interface!

However, you cannot run the code directly through this page!

Access Kimi K2 via Hugging Face

1. Use Novita AI on Hugging Face in the Website UI

Step 1: Configure API Keys

• Navigate to your user account settings to manage your API keys.
• Add your custom API keys of Novita AI to the Hugging Face.

Step 2: Choose Inference API Modes

• Custom Key Mode: Calls are sent directly to the inference provider, utilizing your own API key.
• HF-Routed Mode: In this mode, no provider token is required. Charges are applied to your Hugging Face account instead of the provider’s account.

Step 3: Explore Compatible Providers on Model Pages

• Model pages display third-party inference providers compatible with the selected model (the ones that are compatible with the current model, sorted by user preference).

It is worth noting that it is not recommended to download this model from Hugging Face for local deployment. With 32 billion activated parameters and 1 trillion total parameters, it is currently the largest open-source model in the world. Running the model locally would require a significant amount of 2,254.25 GB VRAM, roughly equivalent to 28 H100/A100 GPUs.

Access Kimi K2 via API

Novita AI integrates the Anthropic API to use kimi k2 in Claude Code
surpassing many industry providers.
It also provides APIs with 131K context, 131K max output, 2.01s latency, 11.06 TPS throughput, and costs of $0.57/input and $2.30/output, delivering strong support for maximizing Kimi K2’s code agent potential.

Novita AI

Step 1: Log In and Access the Model Library

Log in to your account and click on the Model Library button.

Step 2: Choose Your Model

Browse through the available options and select the model that suits your needs.

Step 3: Start Your Free Trial

Begin your free trial to explore the capabilities of the selected model.

Step 4: Get Your API Key

To authenticate with the API, we will provide you with a new API key. Entering the “Settings“ page, you can copy the API key as indicated in the image.

Step 5: Install the API

Install API using the package manager specific to your programming language.

After installation, import the necessary libraries into your development environment. Initialize the API with your API key to start interacting with Novita AI LLM. This is an example of using chat completions API for python users.

from openai import OpenAI
  
client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    api_key="session_1g0vYAKH0Oir6vI6y4PZIGyFLVvuJiJDx0jZiEeYivQFmDr15mi83mWi-_bdrs0C-Q2hk281SCn1f4oUB49loQ==",
)

model = "moonshotai/kimi-k2-instruct"
stream = True # or False
max_tokens = 65536
system_content = ""Be a helpful assistant""
temperature = 1
top_p = 1
min_p = 0
top_k = 50
presence_penalty = 0
frequency_penalty = 0
repetition_penalty = 1
response_format = { "type": "text" }

chat_completion_res = client.chat.completions.create(
    model=model,
    messages=[
        {
            "role": "system",
            "content": system_content,
        },
        {
            "role": "user",
            "content": "Hi there!",
        }
    ],
    stream=stream,
    max_tokens=max_tokens,
    temperature=temperature,
    top_p=top_p,
    presence_penalty=presence_penalty,
    frequency_penalty=frequency_penalty,
    response_format=response_format,
    extra_body={
      "top_k": top_k,
      "repetition_penalty": repetition_penalty,
      "min_p": min_p
    }
  )

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

Step 6: Monitor LLM API Metrics

Systematic evaluation helps determine the optimal deployment strategy based on specific requirements.

• Response Time: Measure end-to-end latency for typical requests.
• Throughput: Test concurrent request handling capacity.
• Reliability: Monitor uptime and error rates over time.
• Quality: Compare output consistency across deployment methods.

You can access these metrics through the LLM Metrics Console.

Access Kimi K2 via Claude Code and Fast MCP

Part 1: Environment Setup and Prerequisites

1.1 System Requirements Check

Before starting, ensure your system meets these requirements:

Windows Systems:

• Windows 10 or higher
• Node.js 18+
• Python 3.8+
• PowerShell or Command Prompt access

Mac Systems:

• macOS 10.15 or higher
• Node.js 18+
• Python 3.8+
• Terminal access

Verification Commands:

# Check Node.js version
node --version

# Check Python version
python --version
# or
python3 --version

1.2 Obtaining Novita AI API Key

1. Visit Novita AI website and create an account
2. Log into your dashboard
3. Navigate to “Key Management” section
4. Click “Create New Key” to generate your API key
5. Important: Copy and securely store the API key immediately (shown only once)

Part 2: Claude Code Installation

2.1 Windows Installation Process

Open Command Prompt or PowerShell and execute:

# Global installation of Claude Code
npm install -g @anthropic-ai/claude-code

# Install Windows-specific version
npx win-claude-code@latest

2.2 Mac Installation Process

Open Terminal and run:

# Global installation of Claude Code
npm install -g @anthropic-ai/claude-code

2.3 Installation Verification

# Check Claude Code version
claude --version

# View help information
claude --help

Part 3: Environment Variables Configuration

3.1 Windows Environment Setup

Method 1: Temporary Setup (current session only)

set NOVITA_API_KEY=Your_Novita_API_Key
set ANTHROPIC_MODEL=moonshotai/kimi-k2-instruct
set ANTHROPIC_SMALL_FAST_MODEL=moonshotai/kimi-k2-instruct

Method 2: Permanent Setup

1. Right-click “This PC” → “Properties”
2. Click “Advanced system settings”
3. Click “Environment Variables”
4. Add the above variables in “User variables”

3.2 Mac Environment Setup

Method 1: Temporary Setup (current session only)

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="Your_Novita_API_Key"
export ANTHROPIC_MODEL="moonshotai/kimi-k2-instruct"
export ANTHROPIC_SMALL_FAST_MODEL="moonshotai/kimi-k2-instruct"

Method 2: Permanent Setup

# Edit configuration file
nano ~/.zshrc

# Add environment variables
export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="Your_Novita_API_Key"
export ANTHROPIC_MODEL="moonshotai/kimi-k2-instruct"
export ANTHROPIC_SMALL_FAST_MODEL="moonshotai/kimi-k2-instruct"

# Reload configuration
source ~/.zshrc

Part 4: Fast MCP Server Development

4.1 Python Dependencies Installation

# Install MCP SDK
pip install fastmcp

# Install additional dependencies
pip install requests uvicorn

4.2 Create MCP Server Script

Create a file named novita_mcp_server.py:

import os
import json
from mcp.server.fastmcp import FastMCP
import requests
from typing import Dict, Any

# Validate API key
if not os.environ.get('NOVITA_API_KEY'):
    raise ValueError("NOVITA_API_KEY environment variable is required")

base_url = "https://api.novita.ai/v3"
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {os.environ['NOVITA_API_KEY']}"
}

mcp = FastMCP("Novita_API")

@mcp.tool()
def list_models() -> str:
    """
    List all available models from the Novita API.
    """
    try:
        url = base_url + "/openai/models"
        response = requests.get(url, headers=headers, timeout=30)
        response.raise_for_status()
        data = response.json()["data"]
        
        text = "Available Models:\n\n"
        for model in data:
            text += f"ID: {model['id']}\n"
            text += f"Description: {model.get('description', 'N/A')}\n"
            text += f"Type: {model.get('model_type', 'N/A')}\n\n"
        
        return text
    except Exception as e:
        return f"Error fetching models: {str(e)}"

@mcp.tool()
def chat_with_model(model_id: str, message: str) -> str:
    """
    Send a message to a specific model and get a response.
    """
    try:
        url = base_url + "/openai/chat/completions"
        payload = {
            "model": model_id,
            "messages": [{"role": "user", "content": message}],
            "max_tokens": 2000,
            "temperature": 0.7
        }
        response = requests.post(url, json=payload, headers=headers, timeout=60)
        response.raise_for_status()
        
        content = response.json()["choices"][0]["message"]["content"]
        return content
    except Exception as e:
        return f"Error communicating with model: {str(e)}"

if __name__ == "__main__":
    mcp.run(transport="stdio")

Part 5: Running the MCP Server

5.1 Set Novita API Key

# Windows
set NOVITA_API_KEY=your_actual_api_key_here

# Mac/Linux
export NOVITA_API_KEY="your_actual_api_key_here"

5.2 Start the MCP Server

# Run the server
python novita_mcp_server.py

The server will start and listen for MCP protocol communications via STDIO.

Part 6: Claude Code Integration

6.1 Create MCP Configuration

Create a configuration file for Claude Code to connect to your MCP server. Save the file as mcp_config.json in the root directory of your Claude Code project (where claude . command is executed):

{
  "mcpServers": {
    "novita": {
      "command": "python",
      "args": ["path/to/novita_mcp_server.py"],
      "env": {
        "NOVITA_API_KEY": "your_api_key_here"
      }
    }
  }
}

6.2 Launch Claude Code with MCP

Navigate to your project directory and start Claude Code:

# Navigate to project directory
cd your-project-directory

# Start Claude Code
claude .

Part 7: Using Kimi-K2 in Claude Code

7.1 Basic Usage Examples

Example 1: Generate a Python Web Application

Create a Flask web application with the following features:
- User authentication system
- Database integration using SQLAlchemy
- RESTful API endpoints
- Basic frontend with HTML templates

Example 2: Code Analysis and Optimization

Analyze the following codebase and suggest optimizations:
- Identify performance bottlenecks
- Recommend code structure improvements
- Suggest security enhancements

Kimi K2 is undeniably a strong contender in the world of AI code agents. Its advanced training in tool use and coding, combined with competitive performance in benchmarks, positions it as a top-tier choice for most coding scenarios. While it may not always outperform proprietary models like Claude, its affordability and versatility make it an excellent option for developers seeking high-performance at a reasonable cost.

Frequently Asked Questions

Novita AI is the All-in-one cloud platform that empowers your AI ambitions. Integrated APIs, serverless, GPU Instance — the cost-effective tools you need. Eliminate infrastructure, start free, and make your AI vision a reality.

Recommend Reading

• Deepseek R1 0528 vs O3: Can China’s Model Beat the Best?
• DeepSeek R1 0528 Cost: API, GPU, On-Prem Comparison
• Llama 3.2 3B vs DeepSeek V3: Comparing Efficiency and Performance.