Kimi K3 + Graph Engineering: 85% Lower Token Costs and 18% Better Accuracy

Most people use AI like an expensive search engine. Open a chat, ask a question, get an answer, close the tab. Next day they start from zero because the AI remembers nothing.

But there are developers making $10,000-20,000 a month simply because their AI system responds twice as fast, gives more accurate answers and costs 85% less than their competitors. They're not using some secret model. They built the right architecture around a regular model.

It's called Kimi K3 + Graph Engineering. Microsoft spent years proving it works - 85% lower costs, 18% better accuracy.

Here's how to build this yourself from scratch in a week.

Why regular RAG stops working at some point

Most developers build AI systems the same way. User asks something, the system searches through documents, finds similar text fragments, model generates an answer. Works fine for simple questions. Falls apart completely for complex ones.

Ask "why did our sales drop in March?" and regular RAG finds documents with the words "sales" and "March." It finds fragments. It doesn't find the chain of causes.

1Regular RAG answer:
2Here are 5 documents mentioning sales in March.
3
4Graph Engineering answer:
5Sales dropped because of a release delay
6caused by a supplier problem
7triggered by a warehouse failure
8which generated negative reviews
9which reduced conversion by 23%.

Same model. Same data. Completely different result - because one system searches text and the other searches connections between real facts.

This is what Microsoft, Stanford and Anthropic all independently figured out. And it's why the developers who understand this are moving faster than everyone else.

What a knowledge graph actually is

A knowledge graph stores information as triples:

1Subject → Relation → Object

Real examples:

1Kimi K3       → developed by     → Moonshot AI
2Kimi K3       → context window   → 1 million tokens
3Microsoft     → built            → GraphRAG
4GraphRAG      → reduces costs by → 85%
5Anthropic     → created          → Claude
6Claude        → supports         → MCP

Every piece of information is an explicit connection between two entities. Not a paragraph of text that might contain this information somewhere - a structured fact you can query directly.

1Regular database:
2Table of companies
3Table of products
4No explicit connections between them
5
6Knowledge graph:
7Company → created → Product
8Product → competes with → Other Product
9Other Product → owned by → Other Company
10Company → invested in → Other Company

The graph doesn't just store facts. It stores how facts connect to each other. That's what makes complex reasoning possible - and what regular RAG can never do no matter how good the model is.

Stanford AI Lab defines a knowledge graph as a structured database where information is represented as a network of entities and relationships in subject-relation-object triples. Used in search, recommendations and tasks where you need to find indirect connections.

ai.stanford.edu/blog/introduction-to-knowledge-graphs

Why Kimi K3 is the right model for this architecture

Most models have 128,000-200,000 token context windows. Kimi K3 has one million. This isn't just an impressive number - it's an architectural advantage specifically for Graph Engineering.

A graph returns subgraphs, chains of evidence, lists of connected entities. All of this takes up space in the context window. With a small context you have to cut the graph. With one million tokens the entire relevant part of the graph fits in one session.

1Kimi K3 architecture:
22.8 trillion total parameters
3896 experts in MoE, 16 active per token
41,048,576 token context window
5Native image analysis
6Kimi Delta Attention for long sequences
7Attention Residuals for preserving signals between layers

kimi.com/blog/kimi-k3

Kimi Delta Attention is a hybrid mechanism that reduces the cost of working with long sequences. For Graph Engineering this means the system can pass the model large subgraphs, long evidence lists, dozens of documents and repository structure without catastrophic cost increases.

But even one million tokens is temporary memory. After the session everything disappears.

11M token context   =  large working surface per session
2Knowledge graph    =  permanent structured memory between sessions

Kimi K3 gives scale and reasoning. Graph Engineering gives memory and structure. Together they solve different problems at the same time.

Document 1 - Microsoft GraphRAG

github.com/microsoft/graphrag

arxiv.org/abs/2603.22528

Microsoft built GraphRAG and open-sourced it. The numbers from their research are the most concrete evidence available for what Graph Engineering actually delivers versus regular RAG.

The architecture converts unstructured text into a full knowledge graph:

1Load documents
2↓
3Chunk documents
4↓
5Extract entities and relations
6↓
7Build graph
8↓
9Detect communities
10↓
11Generate community reports
12↓
13Embed entities and reports
14↓
15Local Search / Global Search

Key insight from Microsoft: regular RAG answers local questions well - find information about this specific entity. It fails on global questions - what are the main patterns across these 10,000 documents, what connects these events across the entire dataset.

Graph Engineering answers both.

1Local Search   |  what happened with supplier X in March
2               |  finds specific node and its connections
3
4Global Search  |  what are the main risk patterns
5               |  across all our supplier relationships
6               |  finds patterns across the entire graph

Real numbers from the ChatP&ID research:

1Accuracy improvement      |  18% higher than raw document approach
2Token cost reduction      |  85% lower than loading structured files directly
3Cost per task             |  approximately $0.004 in tested configuration

Document 2 - Three modes of combining LLM and Knowledge Graph

arxiv.org/abs/2306.08302

One of the strongest theoretical papers on combining language models and knowledge graphs describes three modes:

1Mode 1 - KG-enhanced LLM
2Graph gives the model facts and structure
3Model generates better answers
4
5Mode 2 - LLM-augmented KG
6Model creates, cleans and expands the graph
7Graph gets better over time
8
9Mode 3 - Synergized LLM + KG
10Graph and model improve each other mutually
11Most powerful mode

For Kimi K3 + Graph Engineering the third mode works best. Kimi K3 extracts new facts and adds them to the graph. The graph gives Kimi K3 structured context for reasoning. The cycle repeats and the system gets better with every iteration.

Document 3 - Relational Memory for language models

direct.mit.edu/tacl/article/doi/10.1162/tacl_a_00476

MIT Press, Transactions of the Association for Computational Linguistics.

The research shows what happens when you connect a language model to relational memory - a knowledge graph of relationships instead of text fragments.

1Text context
2↓
3Extract relevant relations from graph
4↓
5Relational Memory
6↓
7Language model
8↓
9More coherent and accurate generation

Key finding: models with access to explicit relationship structures produce more coherent text and make fewer logical errors than models working from text alone.

This is the scientific explanation for why Graph Engineering works. The model doesn't have to infer relationships from text. The relationships are explicit in the graph. The model uses them directly.

Published under CC BY 4.0 - can be freely used with attribution.

Document 4 - Scaling Laws for Knowledge Graph Engineering

arxiv.org/abs/2505.16276

Research that compared 26 open-source models on knowledge graph engineering tasks. The conclusion is one of the most important findings in the field:

1Larger model + bad graph   |  worse results
2Smaller model + good graph |  better results

The right graph beats the bigger model. Every time.

Same conclusion Microsoft reached with GraphRAG and Anthropic reached with Claude Code - the system around the model determines the output more than the model itself. Graph Engineering is the most concrete implementation of that principle.

Document 5 - Agent-as-a-Graph

arxiv.org/abs/2511.18194

This paper shows how to represent not just knowledge but agents and tools as nodes in a graph.

1User question
2↓
3Graph of capabilities
4↓
5Select research agent
6↓
7Select GitHub tool
8↓
9Select ArXiv tool
10↓
11Select graph database tool
12↓
13Kimi K3 coordinates execution

Authors report Recall@5 improvement of 14.9% and nDCG@5 improvement of 14.6% versus comparable retrievers on LiveMCPBenchmark.

For Kimi K3 this means the graph can manage not just knowledge but which agent and which tool to use for each specific task.

Document 6 - Kimi Code and Agent SDK

github.com/MoonshotAI/kimi-code

github.com/MoonshotAI/kimi-agent-sdk

Kimi Code is a terminal agent that can:

1Read and edit code
2Run shell commands
3Search files
4Fetch web pages
5Analyze the result of each step
6Independently choose the next action
7Supports MCP
8Lifecycle hooks
9Approval modes

Kimi Agent SDK lets you use Kimi Code as the foundation of your own agent. It reuses the tools, skills and MCP server configuration from Kimi Code.

For Graph Engineering this is a ready-made execution layer. The graph provides structured knowledge and reasoning paths. Kimi Code takes actions in the real environment. The SDK ties everything together.

The full system architecture

1Step 1 - Ingestion Layer
2PDFs, websites, databases, APIs, Slack, Notion
3↓
4
5Step 2 - Extraction Layer
6Kimi K3 extracts entities and relationships
7
8{
9  "entity": "Kimi K3",
10  "type": "AI model",
11  "relations": [
12    {
13      "predicate": "developed_by",
14      "object": "Moonshot AI",
15      "confidence": 0.98
16    }
17  ]
18}
19
20↓
21
22Step 3 - Resolution Layer
23System resolves whether these are the same entity:
24Moonshot AI / Moonshot / Beijing Moonshot / 月之暗面
25
26↓
27
28Step 4 - Graph Storage
29Neo4j / Memgraph / Amazon Neptune / PostgreSQL
30
31↓
32
33Step 5 - Retrieval Layer
34Vector search + Entity lookup + Path search
35Community search + Temporal filtering
36
37↓
38
39Step 6 - Agent Layer
40Kimi K3:
41Plans the approach
42Chooses the right tool
43Generates Cypher or SPARQL queries
44Analyzes subgraph
45Runs web research
46Draws conclusions
47Identifies the next knowledge gap
48
49↓
50
51Step 7 - Verification Layer
52Checks evidence coverage
53Finds contradictions
54Evaluates confidence
55Verifies sources
56
57↓
58
59Step 8 - Graph Update
60New facts added to graph
61Contradictions flagged
62Old information gets timestamp

This is a closed knowledge-action loop. Kimi K3 doesn't just read the graph. It identifies what's missing, forms sub-questions, selects a node or subgraph, runs a search, checks the result, adds a new fact and re-evaluates the hypothesis.

Five prompts that run the entire pipeline

Graph Engineering doesn't replace prompts. It uses them at each specific stage.

Prompt 1 - Extraction

1Extract all organizations, people, products and events.
2
3For each entity return:
4- canonical_name
5- type
6- description
7- source
8
9For each relationship return:
10- source_entity
11- relation_type
12- target_entity
13- evidence
14- confidence_score

Prompt 2 - Normalization

1Compare the following entities.
2Determine whether they refer to:
3- the same entity
4- related but different entities
5- unrelated entities
6
7Return canonical name and explanation.
8Do not merge entities without clear evidence.

Prompt 3 - Graph Query

1Translate the user question into a Cypher query.
2Use only relationships present in the schema.
3Do not invent labels or properties.
4Return the query and explanation of the logic.

Prompt 4 - Grounded Answer

1Answer using only the retrieved graph paths.
2For every conclusion:
3- identify the supporting nodes
4- identify the relationship path
5- state uncertainty clearly
6- do not infer causation from correlation

Prompt 5 - Graph Maintenance

1Compare new facts with the existing graph.
2Classify each fact as:
3- new
4- duplicate
5- contradiction
6- update
7- uncertain
8
9Do not overwrite existing facts without evidence.

Five businesses you can build on this system

1 - Investment Research

1Company
2├── founders and their previous projects
3├── investors and their portfolio
4├── competitors and their strategies
5├── legal risks
6├── patents
7├── job openings as strategy signal
8└── financial metrics over time

Kimi K3 reads reports and news. The graph shows hidden connections between companies, shared investors, supplier dependencies and personnel signals. Clients: investment funds, law firms, M&A consultants. $2,000-10,000 per client per month.

2 - Engineering Intelligence

1GitHub commits + Jira tickets + Linear tasks
2↓
3Graph of Engineering Work
4↓
55x faster incident detection
650% less meeting time
7Automatic release notes

anthropic.com/customers/graph

LaunchNotes already sells this. The market is every engineering team using more than one project management tool.

3 - Scientific Research Engine

1Paper → author → institution → method → dataset → result
2↓
3Which GraphRAG methods use community detection,
4on which datasets they were tested
5and which papers contradict each other

Regular search gives a list of documents. A graph system builds a map of evidence and contradictions.

4 - Cybersecurity Threat Graph

1IP → domain → certificate → malware → campaign → actor
2↓
3Kimi K3 analyzes threat reports
4Maps indicators across sources
5Explains attack paths
6Updates threat graph automatically

5 - Personal Knowledge OS

1People ↔ Meetings ↔ Projects ↔ Documents ↔ Decisions ↔ Promises
2↓
3Questions Kimi K3 can answer:
4Who is blocking this task?
5What decision did we make and what was it based on?
6What did I promise to do this month?
7Which old assumptions are no longer valid?

Where to start this week

1Day 1  |  install Neo4j locally
2       |  read DSPy README
3       |  github.com/stanfordnlp/dspy
4       |  understand the difference between prompting
5       |  and programming a system
6
7Day 2  |  take one set of documents
8       |  run Kimi K3 via API
9       |  extract first entities and relationships
10       |  save to Neo4j
11
12Day 3  |  build first retrieval layer
13       |  combine vector search and graph search
14       |  test on a complex question RAG can't answer
15
16Day 4  |  connect Kimi Code via MCP
17       |  github.com/MoonshotAI/kimi-code
18       |  let the agent read the graph and add new facts
19       |  run first knowledge-action loop
20
21Day 5  |  measure the result
22       |  compare accuracy vs regular RAG
23       |  compare token costs
24       |  find first real client use case

What Microsoft, Stanford and Anthropic figured out together

1Microsoft GraphRAG    |  graph cuts costs 85%, improves accuracy 18%
2Stanford DSPy         |  model is a node in a graph, not the center
3Stanford Scaling Laws |  smaller model + good graph beats bigger model
4MIT Press Research    |  explicit relationships improve coherence and accuracy
5Anthropic LaunchNotes |  5x faster incident detection, 50% less meeting time

Kimi K3 is the engine. Graph Engineering is the map, the memory and the coordinate system. Without the engine the graph doesn't act. Without the graph the engine moves very fast but doesn't always know where it's going.

Most developers will keep building regular RAG and wonder why complex questions give bad answers. A few will spend a week building a graph system and never go back to searching text.

You build your own life - so choose the right path.

/ If this was useful - follow /