memoket-kite README

The project's README from github.com/memoket/memoket-kite. As one markdown file: README.md.

Memoket × KITE: the memory inside Memoket

Follow the thread, not the nearest match.

Open-source and vector-free, KITE achieves 🥇 93.51% on LoCoMo and 🥇 85.60% on LongMemEval-S, with gpt-4.1-mini used across all benchmark stages and an average reader context of only ~1.6K tokens per question.

Memoket website Join Memoket on Discord Follow Memoket on X Follow Memoket on Instagram Follow Memoket on Facebook


KITE at a glance: conversations become source-linked memory facts, memory settles under a governed topic map, a question compiles to an inspectable plan, and the answer arrives with receipts.

💡 Why KITE by Memoket

Most AI memory turns every sentence into a cloud of numbers and hands back whatever lands closest to your question. It always returns something, even when the answer was never there, and it cannot show you why.

KITE by Memoket reads what a question means, not how it sounds.

"Who's the decision-maker on the Henderson account now?"

Nothing in memory says decision-maker:

  • March. Marcus: "I'll sign off on Henderson."
  • June. The new VP of Ops: "Dana owns Henderson from here."

Both were filed under the same topic when they were written. Then now sorts them by date. Similarity has no notion of now: nearest-match memory rates March just as relevant and answers "Marcus", with nothing to tell you it is wrong. KITE answers "Dana", with the June line attached.

Nearest-match memory 🪁 KITE by Memoket
Finds whatever sounds like the question the facts that answer it
When it was never said returns something anyway comes back empty, and says so
Why this answer? a similarity score a readable plan, with who said it and when
Runtime stack embeddings · vector DB · rerankers one portable, topic-indexed file
Ask again tomorrow depends on the index that day the same plan walks the same steps

⚙️ How It Works

The whole idea in one line: conversations settle into facts under topics, and a question finds its topic and pulls that topic's memories, receipts included.

1 · Message → Fact

A user says, "I moved to Tokyo on July 26." KITE by Memoket extracts what happened and files it under its topics, keeping the original message as evidence:

<fact t="2026-07-26" kind="event" who="user"
      place="tokyo" event="move" src="chat1L1">
  The user moved to Tokyo on 26 July 2026.
</fact>
<line id="chat1L1" who="user">I moved to Tokyo on July 26.</line>

2 · Question → Plan

When the agent asks "Where does the user live now?", KITE by Memoket compiles the question into a plan you can read, validate, and cache:

{
  "select": "facts",
  "where": {"who": ["user"], "event": ["move"]},
  "pipe": [
    {"op": "sort", "key": "t", "desc": true},
    {"op": "head", "n": 1}
  ]
}

3 · Plan → Execution

The executor runs the plan over the topic index. Keywords and associations come first, then conditions filter down to the one moment that answers the question:

SEARCH facts
FILTER who = "user" AND event = "move"
SORT BY event_time DESC
TAKE 1

The same validated plan always follows the same steps over the same memory, with no embeddings and no vector database anywhere.

4 · Evidence → Answer

Answer: Tokyo
Source: chat1L1, "I moved to Tokyo on July 26."

Key Features

🚫 No vector stack

No embeddings, no vector database, no layers to embed, sort, and re-rank every result.

🗂️ Structured facts

Conversations crystallize into typed, dated, topic-indexed memory you can open and read.

🔍 Inspectable queries

Every question becomes a symbolic plan, revealing exactly how each answer was matched.

🕐 Time-aware retrieval

People, events, dates, and updates handled directly, so "now" means now.

🧾 Shows its work

Evidence links straight back to the moment it came from: who said it, when, and the actual words.

🤷 Knows what it doesn't know

When something was never said, the search comes back genuinely empty, and KITE says so.

🚀 Quick Start

1. Install and configure

python -m pip install memoket-kite
export OPENAI_API_KEY="sk-..."
mkdir -p artifacts
curl -fsSL \
  https://raw.githubusercontent.com/memoket/memoket-kite/main/examples/data/demo_codebook.xml \
  -o artifacts/quickstart.xml

Using another OpenAI-compatible provider? Set OPENAI_BASE_URL as well.

2. Remember

Turn a conversation into structured, source-backed facts:

from memoket_kite import Memory

memory = Memory.load("artifacts/quickstart.xml")
memory.remember(
    [{"role": "user", "content": "I moved to Tokyo."}],
    session_id="session_1",
)

3. Recall

Compile a question into a plan and retrieve matching facts, each carrying its sources:

from memoket_kite import Memory

memory = Memory.load("artifacts/quickstart.xml")

for fact in memory.recall("Where did the user move?"):
    print(fact.content)
    print(fact.sources)

4. Answer

Generate an answer from the retrieved evidence and keep the receipts:

from memoket_kite import Memory

memory = Memory.load("artifacts/quickstart.xml")

result = memory.answer_with_evidence("Where did the user move?")
print(result.text)  # "The user moved to Tokyo."
for fact in result.evidence:
    print(fact.content, fact.sources)  # the moments the answer stands on

print(memory.answer("Where did the user move?"))  # just the text

Full reference in docs/api.md; more runnable examples in examples/.

📊 Benchmark Results

KITE by Memoket posts the top overall score on both public long-conversation memory benchmarks. It is the only system up there that uses no vectors, and it reads less context than any capable rival.

Benchmark Overall Accuracy Avg. Reader Context
LoCoMo 🥇 93.51% 1.51k tokens
LongMemEval-S 🥇 85.60% 1.65k tokens

All systems are evaluated under one shared protocol, with gpt-4.1-mini as the common reader and judge; the exact rubrics are in the LoCoMo protocol and LongMemEval protocol. Reader context is the mean per-question evidence budget: what the reader actually gets to see, measured by the same ledger on every question.

Each figure comes from a reference run under the default configuration, with gpt-4.1-mini reading and judging and no ablation flags set. The reproduction contract pins the dataset revisions, protocols, model IDs, expected row counts, and reported scores. The provided scripts rebuild the evaluation locally from the official datasets with a configured compatible LLM endpoint.

How a local run is recorded

Every rebuilt run writes a local manifest naming the exact commit, corpus digest, tokenizer, and plan-cache digest it used. Judging records the answers, verdicts, and score in a second manifest keyed to the first. A completed run can validate that seal and recompute its metrics offline; the reference verifier also checks the manifest-declared paths, counts, and reported aggregate. Details are in the benchmark guide and reproducibility notes; the benchmark corpora keep their own licences, spelled out in LICENSE-DATA.md.

🔗 Integrations

KITE by Memoket is a plain Python library: three calls take you from a raw conversation to a cited answer. Integrations across the agent ecosystem (Claude Code, Codex, Cursor, OpenCode, and more) are next on the roadmap.

Want yours first? Tell us on Discord.

the string ties into Memoket

Download on the App Store    Get it on Google Play

✨ Experience KITE with Memoket

The memory you just read about ships today. KITE is the algorithm inside every Memoket: the same topic-filed facts, the same line back to the source, running on your own device. Ask it "didn't this client say their fiscal year ends in March?" months later, and it surfaces the exact moment: who said it, when, and in their words.

Memoket captures memories; KITE is the memory itself.

https://github.com/user-attachments/assets/685ac90d-95ab-4114-a7d3-c22ec3db94a0

See more of Memoket in action →

🤝 Community

📖 Citation

A technical report is in preparation; BibTeX will land here with the arXiv release. Until then, please cite this repository.

📄 License

KITE by Memoket is released under the Apache License 2.0.


Like its name, KITE by Memoket stays light enough to fly, always on a line back to the truth. 🪁

memoket-kite (memoket/memoket-kite)

Searching Database…

150 ·GitHub
Memoket-kite
What is this?KITE is an open-source, vector-free long-term memory engine for AI agents: it turns conversations into structured, topic-indexed facts and answers questions with inspectable retrieval plans instead of embedding similarity search, topping the LoCoMo and LongMemEval benchmarks.
Is this a standalone app or a library I call from my code?It is a plain Python library with a three-call workflow (remember, recall, answer) that you embed in your own agent code, not a hosted service or GUI app.
How do I get it running?After installing and configuring it, you call three steps: Remember to turn a conversation into structured facts, Recall to compile a question into a plan and pull matching facts, and Answer to generate a cited response from that evidence.
Do I need an OpenAI API key to use it?Yes, KITE relies on an OpenAI-compatible LLM endpoint for extraction and answering (gpt-4.1-mini is used in the published benchmarks), and you can point it at another compatible provider via an environment variable.
Does it already plug into tools like Claude Code or Cursor?Not yet; direct integrations with coding agents such as Claude Code, Codex, Cursor, and OpenCode are listed as upcoming roadmap items, so today you use it as a raw Python library.
How is KITE different from a typical vector-database memory system?Instead of embeddings, a vector store, and rerankers, KITE extracts typed, dated facts filed under topics and answers questions with a symbolic, readable retrieval plan, so it can return genuinely empty results instead of a plausible-sounding wrong answer.
Why does it handle time-sensitive questions better than similarity search?Facts under the same topic are sorted by date, so when information changes (like who now owns an account), the newer fact wins instead of both old and new entries scoring equally relevant by similarity.
What's the relationship between KITE and Memoket?KITE is the underlying retrieval algorithm; Memoket is a consumer product built on top of it that runs the same topic-filed, source-linked memory locally on a user's device.
How reproducible are the benchmark numbers?Each run writes a local manifest recording the exact commit, corpus digest, tokenizer, and plan-cache digest used, plus a second manifest for judging results, and a reference verifier can recompute the metrics offline from these seals.
What are similar projects?mem0, EverOS, VoiceMem, nautilus-compass, LongMemory, Raven, Memori, Recuris
Which topics is it in?llm-memory, memory-engine, retrieval, ai-memory, genai, memory-management, llm-evaluation, long-term-memory, knowledge-management, evaluation, agent-memory, memory
Creator
memoket
Size
19 MB
Stars
150
Updated
CommitOct 12Releasev0.1.0Aug 13
Age
2mo
Commits · 90 Days