Kimi K2.6 vs GPT-4o: 128K Context Window — Real Pricing & Performance Data

import openai

client = openai.OpenAI(
    api_key="your-aiwave-api-key",
    base_url="https://aiwave.live/v1"
)

def summarize_long_document(text: str, focus_areas: list[str]) -> dict:
    # Summarize a long document (up to 128K tokens) with focus on specific areas.
    # Uses Kimi K2.6 for cost-effective long-context processing.
    #
    # Cost estimate:
    #   - 100K input tokens: 100,000 * $1.09/1M = $0.109
    #   - 2K output tokens: 2,000 * $4.60/1M = $0.0092
    #   - Total: ~$0.118 per document

    focus_prompt = "\n".join(f"- {area}" for area in focus_areas)

    response = client.chat.completions.create(
        model="kimi-k2.6",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a senior research analyst. Summarize the document "
                    "with special attention to the requested focus areas. "
                    "For each area, provide: key findings, supporting evidence "
                    "locations (page/section), and confidence level."
                )
            },
            {
                "role": "user",
                "content": f"Document:\n\n{text}\n\nFocus areas:\n{focus_prompt}"
            }
        ],
        temperature=0.1,
        max_tokens=4000
    )

    return {
        "summary": response.choices[0].message.content,
        "model": "kimi-k2.6",
        "input_tokens": response.usage.prompt_tokens,
        "output_tokens": response.usage.completion_tokens,
        "estimated_cost_usd": (
            response.usage.prompt_tokens * 1.09 / 1_000_000
            + response.usage.completion_tokens * 4.60 / 1_000_000
        )
    }

def compare_cost(input_tokens: int, output_tokens: int) -> None:
    models = {
        "Kimi K2.6": (1.090, 4.600),
        "GPT-4o":    (2.500, 10.000),
    }
    print(f"Input: {input_tokens:,} tokens | Output: {output_tokens:,} tokens")
    print("-" * 50)
    for name, (inp, out) in models.items():
        cost = input_tokens * inp / 1e6 + output_tokens * out / 1e6
        print(f"{name:12s}: ${cost:.4f}")

# Example: 100K input, 2K output (typical long doc summary)
compare_cost(100_000, 2_000)
# Output:
# Input: 100,000 tokens | Output: 2,000 tokens
# --------------------------------------------------
# Kimi K2.6   : $0.1180
# GPT-4o      : $0.2700

from typing import TypedDict

class DocAnalysis(TypedDict):
    doc_id: str
    summary: str
    key_claims: list[str]
    cross_refs: list[str]

def analyze_document_set(documents: list[dict], query: str) -> list[DocAnalysis]:
    # Cost per document (100K input, 2K output): ~$0.118
    # Cost per synthesis (200K input, 3K output): ~$0.232
    # Total for 10 docs + synthesis: ~$1.41
    # Same workload on GPT-4o: ~$3.23
    individual_results = []

    for doc in documents:
        response = client.chat.completions.create(
            model="kimi-k2.6",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "Extract: 1) A 200-word summary, 2) Key claims, "
                        "3) References to external documents."
                    )
                },
                {"role": "user", "content": f"Document ID: {doc['id']}\n\n{doc['text']}"}
            ],
            temperature=0.1,
            max_tokens=2000
        )
        individual_results.append({
            "doc_id": doc["id"],
            "summary": response.choices[0].message.content
        })

    # Synthesis pass: find contradictions and agreements
    synthesis_prompt = "\n".join(
        f"Doc {r['doc_id']}: {r['summary']}" for r in individual_results
    )

    synthesis = client.chat.completions.create(
        model="kimi-k2.6",
        messages=[
            {
                "role": "system",
                "content": f"Given these summaries, answer: {query}\nIdentify contradictions and agreements."
            },
            {"role": "user", "content": synthesis_prompt}
        ],
        temperature=0.1,
        max_tokens=3000
    )

    return individual_results + [{"doc_id": "synthesis", "summary": synthesis.choices[0].message.content}]

ROUTING_MODEL = "glm-4.7-flash"  # $0.03/1M, budget tier for initial triage
DEEP_MODEL = "kimi-k2.6"          # $1.09/$4.60 for full analysis

def analyze_document_pipeline(text: str, query: str) -> str:
    # Step 1: Budget triage — determine if deep analysis is needed
    triage = client.chat.completions.create(
        model=ROUTING_MODEL,
        messages=[
            {"role": "system", "content": "Does this query require deep analysis? Reply YES or NO."},
            {"role": "user", "content": f"Query: {query}\n\nDoc length: {len(text)} chars"}
        ],
        max_tokens=10
    )

    if "YES" in triage.choices[0].message.content:
        return summarize_long_document(text, [query])
    else:
        return "Triage: Simple lookup — no deep analysis needed."