Kimi K2.5 GitHub Resources: Repos, Tools & Community Projects 2026

# Clone the repository
git clone https://github.com/MoonshotAI/kimi-cli.git

# Install from source
cd kimi-cli
pip install -e .

kimi-cli/
├── kimi/                 # Main package
├── docs/                 # Documentation
├── tests/                # Test suite
├── examples/             # Usage examples
└── README.md            # Getting started guide

npx create-next-app@latest my-kimi-app
cd my-kimi-app
npm install openai

mkdir kimi-fastapi-starter && cd kimi-fastapi-starter
python -m venv .venv && source .venv/bin/activate
pip install fastapi uvicorn openai

pip install openai

from openai import OpenAI

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

# Simple completion
response = client.chat.completions.create(
    model="kimi-k2-5",
    messages=[{"role": "user", "content": "Hello!"}]
)

# Streaming
for chunk in client.chat.completions.create(
    model="kimi-k2-5",
    messages=[{"role": "user", "content": "Tell me a story"}],
    stream=True
):
    print(chunk.choices[0].delta.content, end="")

npm install openai

import OpenAI from 'openai';

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

const response = await client.chat.completions.create({
  model: 'kimi-k2-5',
  messages: [{ role: 'user', content: 'Explain TypeScript' }],
});

package main

import (
  "bytes"
  "fmt"
  "io"
  "net/http"
)

func main() {
  payload := []byte(`{
    "model":"kimi-k2-5",
    "messages":[{"role":"user","content":"Hello!"}]
  }`)

  req, _ := http.NewRequest("POST", "https://api.moonshot.cn/v1/chat/completions", bytes.NewBuffer(payload))
  req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
  req.Header.Set("Content-Type", "application/json")

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

import openai

# Drop-in replacement
client = openai.OpenAI(
    api_key="your-kimi-api-key",
    base_url="https://api.moonshot.cn/v1"
)

# Works with existing OpenAI code
response = client.chat.completions.create(
    model="kimi-k2-5",
    messages=[{"role": "user", "content": "Hello"}]
)

from langchain_openai import ChatOpenAI

# Use with LangChain
llm = ChatOpenAI(
    model="kimi-k2-5",
    openai_api_key="your-kimi-api-key",
    openai_api_base="https://api.moonshot.cn/v1"
)

from langchain import LLMChain, PromptTemplate

template = """Answer the following question:
Question: {question}
Answer: """

prompt = PromptTemplate(template=template, input_variables=["question"])
chain = LLMChain(llm=llm, prompt=prompt)

response = chain.run("What is machine learning?")

from llama_index.llms.openai import OpenAI
from llama_index.core import Settings

Settings.llm = OpenAI(
    model="kimi-k2-5",
    api_key="your-kimi-api-key",
    api_base="https://api.moonshot.cn/v1"
)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("Summarize the documents")

version: '3.8'
services:
  kimi-api:
    image: vllm/vllm-openai:latest
    command: >
      --model moonshotai/Kimi-K2.5
      --tensor-parallel-size 4
    ports:
      - '8000:8000'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 4
              capabilities: [gpu]

  kimi-web:
    build: ./web
    ports:
      - '3000:3000'
    environment:
      - KIMI_API_URL=http://kimi-api:8000

apiVersion: v1
kind: ConfigMap
metadata:
  name: kimi-config
data:
  MODEL_NAME: 'moonshotai/Kimi-K2.5'
  TENSOR_PARALLEL: '4'
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kimi-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: kimi
  template:
    metadata:
      labels:
        app: kimi
    spec:
      containers:
        - name: vllm
          image: vllm/vllm-openai:latest
          envFrom:
            - configMapRef:
                name: kimi-config
          resources:
            limits:
              nvidia.com/gpu: '4'

name: Kimi K2.5 Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          pip install pytest

      - name: Run tests
        env:
          KIMI_API_KEY: ${{ secrets.KIMI_API_KEY }}
        run: pytest tests/

name: Deploy Kimi K2.5

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Deploy to Kubernetes
        run: |
          kubectl apply -f k8s/
          kubectl rollout status deployment/kimi-deployment

# Clone official cookbook
git clone https://github.com/MoonshotAI/MoonshotAI-Cookbook.git
cd MoonshotAI-Cookbook

# Browse language/framework examples
find examples -maxdepth 2 -type f | head

# Pick an example folder and run according to its README
cd examples
ls