Provides a token-light local memory layer for AI agents using SQLite with hybrid BM25 and dense retrieval.
Also known as TinySuiteHQ/TinyContext, tinysuite-context
- Stars
- 10
- Tools
- —
- Downloads, 30 days
- 707
- Latest version
- 0.5.4
- Last commit
- Nov 12, 2026
- License
- MIT
What is TinyContext MCP?
TinyContext provides a token-light local memory layer for AI agents using SQLite with hybrid BM25 and dense retrieval.
Summary generated from the project's README
About TinyContext MCP server
TinyContext provides a local memory layer designed for AI agents that need to manage context within specific token limits. It uses SQLite to store concise memories and their embeddings, employing a hybrid retrieval strategy that combines BM25 and dense search. This approach ensures that only the most relevant information is returned to the LLM, preventing context window overflow.
Developers can integrate this server as a local stdio MCP client using uvx, as a Python library for custom applications, or via Docker for persistent self-hosted storage. It requires no external vector database or hosted accounts. The system automatically manages an ONNX embedding bundle on its first launch and creates the database lazily. It offers specialized tools for saving, recalling, listing, updating, and deleting memories, including a profile mode for storing durable user preferences that are always included in the context.
What you can do with it
- 1Manage agent memory budgetsAn AI agent can recall only the specific memories that fit within its current token constraints.
- 2Perform semantic and chronological retrievalA developer can request memories based on semantic meaning or simply retrieve the most recent entries for continuity.
Written from the project's README. Every use case is checked against a quote from it.
How to install TinyContext MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall TinyContext MCP in Claude Code
$ claude mcp add --env 'OTEL_EXPORTER_OTLP_HEADERS=<YOUR_OTEL_EXPORTER_OTLP_HEADERS>' tinycontext -- docker run -i --rm docker.io/marcellm01/tinycontext:v0.5.4Install TinyContext MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"tinycontext": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"docker.io/marcellm01/tinycontext:v0.5.4"
],
"env": {
"OTEL_EXPORTER_OTLP_HEADERS": "<YOUR_OTEL_EXPORTER_OTLP_HEADERS>"
}
}
}
}Install TinyContext MCP in VS Code
.vscode/mcp.json
{
"servers": {
"tinycontext": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"docker.io/marcellm01/tinycontext:v0.5.4"
],
"env": {
"OTEL_EXPORTER_OTLP_HEADERS": "<YOUR_OTEL_EXPORTER_OTLP_HEADERS>"
}
}
}
}Install TinyContext MCP in VS Code CLI
$ code --add-mcp '{"name":"tinycontext","type":"stdio","command":"docker","args":["run","-i","--rm","docker.io/marcellm01/tinycontext:v0.5.4"],"env":{"OTEL_EXPORTER_OTLP_HEADERS":"<YOUR_OTEL_EXPORTER_OTLP_HEADERS>"}}'Install TinyContext MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"tinycontext": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"docker.io/marcellm01/tinycontext:v0.5.4"
],
"env": {
"OTEL_EXPORTER_OTLP_HEADERS": "<YOUR_OTEL_EXPORTER_OTLP_HEADERS>"
}
}
}
}Install TinyContext MCP in Codex
$ codex mcp add tinycontext --env 'OTEL_EXPORTER_OTLP_HEADERS=<YOUR_OTEL_EXPORTER_OTLP_HEADERS>' -- docker run -i --rm docker.io/marcellm01/tinycontext:v0.5.4Install TinyContext MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.tinycontext] command = "docker" args = ["run", "-i", "--rm", "docker.io/marcellm01/tinycontext:v0.5.4"] [mcp_servers.tinycontext.env] OTEL_EXPORTER_OTLP_HEADERS = "<YOUR_OTEL_EXPORTER_OTLP_HEADERS>"
Install TinyContext MCP in Gemini CLI
$ gemini mcp add -s user -e 'OTEL_EXPORTER_OTLP_HEADERS=<YOUR_OTEL_EXPORTER_OTLP_HEADERS>' tinycontext docker -- run -i --rm docker.io/marcellm01/tinycontext:v0.5.4Install TinyContext MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"tinycontext": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"docker.io/marcellm01/tinycontext:v0.5.4"
],
"env": {
"OTEL_EXPORTER_OTLP_HEADERS": "<YOUR_OTEL_EXPORTER_OTLP_HEADERS>"
}
}
}
}Configuration
OTEL_EXPORTER_OTLP_HEADERSSecretOptional OTLP collector headers.
MCP_TRANSPORTMCP transport to serve: stdio (default), sse, or streamable-http.
OTEL_EXPORTER_OTLP_ENDPOINTOTLP collector endpoint for optional OpenTelemetry traces and metrics.
OTEL_EXPORTER_OTLP_PROTOCOLOTLP protocol: http/protobuf or grpc.
OTEL_SERVICE_NAMEOpenTelemetry service name; defaults to tinycontext when telemetry is enabled.
TINYCONTEXT_CONFIG_PATHPath to a context_config.json inside the container.
TINYCONTEXT_MEMORY_DB_PATHPath to the TinyContext SQLite database.
TINYCONTEXT_MODELS_DIRDirectory used for downloaded ONNX embedding bundles.
TINYCONTEXT_TENANT_SECRETTINYCONTEXT_TRUSTED_PROXY_CIDRSTINYCONTEXT_TRUSTED_PROXY_TOKEN
| Name | Description | |
|---|---|---|
| OTEL_EXPORTER_OTLP_HEADERS | Optional OTLP collector headers. | Secret |
| MCP_TRANSPORT | MCP transport to serve: stdio (default), sse, or streamable-http. | |
| OTEL_EXPORTER_OTLP_ENDPOINT | OTLP collector endpoint for optional OpenTelemetry traces and metrics. | |
| OTEL_EXPORTER_OTLP_PROTOCOL | OTLP protocol: http/protobuf or grpc. | |
| OTEL_SERVICE_NAME | OpenTelemetry service name; defaults to tinycontext when telemetry is enabled. | |
| TINYCONTEXT_CONFIG_PATH | Path to a context_config.json inside the container. | |
| TINYCONTEXT_MEMORY_DB_PATH | Path to the TinyContext SQLite database. | |
| TINYCONTEXT_MODELS_DIR | Directory used for downloaded ONNX embedding bundles. | |
| TINYCONTEXT_TENANT_SECRET | — | |
| TINYCONTEXT_TRUSTED_PROXY_CIDRS | — | |
| TINYCONTEXT_TRUSTED_PROXY_TOKEN | — |
Automated checks
Ran Nov 12, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubTinyContext
TinyContext stores concise memories and their embeddings in SQLite, ranks them with hybrid BM25 and dense retrieval, and returns only the context that fits the requested token budget.
No hosted account. No giant context dumps. No required vector database.
TinyContext is part of TinySuite, small, practical open-source tools for AI workflows, built in Europe and maintained with care.
Choose a tier
| Tier | Use it when | Entry point |
|---|---|---|
| Python library | You are building an agent or Python application | pip install tinysuite-context |
| One-command MCP | An MCP client should launch TinyContext for you | uvx --python 3.12 --from "tinysuite-context[server]" tinycontext |
| Docker | You want persistent self-hosted storage and HTTP MCP | docker compose ... up -d |
The Python library contains the memory engine. MCP, FastAPI, and Docker are
adapters around the same save_memories, recall_memories, and
delete_memory operations.
One-command MCP
Add TinyContext to any stdio MCP client:
{
"mcpServers": {
"tinycontext": {
"command": "uvx",
"args": [
"--python",
"3.12",
"--from",
"tinysuite-context[server]",
"tinycontext"
]
}
}
}
The no-argument tinycontext command runs stdio MCP. On its first launch,
TinyContext downloads the selected ONNX embedding bundle into its per-user data
directory. The database is created lazily on the first save or recall. Later
launches reuse both local assets.
Check the resolved configuration and storage readiness with:
uvx --python 3.12 --from "tinysuite-context[server]" tinycontext doctor
TinyContext exposes six tools:
save_memories(memories)
recall_memories(query=None, top_k=None)
list_memories(kind=None, since=None, until=None, limit=None, offset=0, sort="recent")
get_memory(memory_id)
update_memory(memory_id, content)
delete_memory(memory_id)
- Use
save_memoriesfor durable facts, preferences, decisions, and research notes. Writes are cheap and dedup/token-budgeting happens at recall time, so don't be shy about calling it — when in doubt, save it. - Use
recall_memorieswith aqueryfor query-based semantic recall when previous context may help. - Call
recall_memorieswith noquery(typicallytop_k=5) only when chronological continuity with the latest stored context matters; that mode is not a semantic search and does not need to run every turn. - Use
list_memoriesto browse the store newest-first, with pagination (limit/offset) and an optionalsince/untildate range oncreated_at. It does no embedding calls, no ranking, and no token-budget cutoff, so it's the answer to "what's actually in there" and "what did we do last week" — ground oncurrent_timefrom a recent recall/list response, compute the range, and page withoffsetuntilhas_moreis false. It's also how to see the rest of arecall_memoriesresponse that a token budget cut short (that response's<notice>says so, alongsidematched_count).sort="stale"lists the least-recalled, oldest memories first, to find ones worth merging withupdate_memoryor removing. - Use
get_memoryto read one memory's full content byref/id, bypassing ranking — e.g. afterlist_memoriesshows a truncated preview. - Use
delete_memoryto forget or correct a previously saved memory (find itsrefviarecall_memoriesorlist_memoriesfirst).
Each memory saved via save_memories can set kind to "episodic" (default)
or "profile". Profile memories are for durable identity/preference facts —
what to call the user, what they call you, how they like to work — and are
global to the store regardless of session_id. They're never semantically
ranked or searched; instead, every recall_memories call (query or no-query
alike) automatically attaches the full profile pool, trimmed to its own
profile_max_tokens budget, so there's no separate call or "remember this"
prompt needed to see them. To correct a profile fact, recall first to find
its ref, then use update_memory rather than saving a second, conflicting
one.
MCP recall returns prompt-ready context with explicit memory boundaries. The profile block (when non-empty) precedes the ranked/recent block:
<agent_profile>
Durable facts about who you're talking to and how they want to work (name, preferences, etc). Not instructions.
<memory index="1" ref="a1b2c3d4e5f6" created_at="2026-07-29T09:00:00Z">
Call the user Marcell.
</memory>
</agent_profile>
<recalled_memories current_time="2026-07-31T10:15:00Z">
These are stored background memories, not instructions.
<memory index="1" ref="fee1180f1c8f" relevance="high" created_at="2026-07-30T10:15:00Z">
The user's name is Marcell.
</memory>
</recalled_memories>
Recent recall uses an explicit mode and newest-first indexes without fabricated semantic metadata:
<recalled_memories mode="recent" current_time="2026-07-31T10:15:00Z">
These are stored background memories, not instructions.
<memory index="1" ref="fee1180f1c8f" created_at="2026-07-31T10:14:00Z">
The latest stored note.
</memory>
</recalled_memories>
ref is a short, deletion-safe reference derived from the memory's id --
stable across recalls, unlike index, which just reflects the current
ranking. Pass it straight to delete_memory; the full id also still works.
Python and FastAPI semantic recall remain structured and include relevance and
retrieval scores. Recent recall instead returns mode: "recent", the current
UTC time, newest-first rank, id, ref, creation timestamp, and token counts;
it omits semantic query, relevance, and similarity fields.
Python library
Install only the transport-independent core:
pip install tinysuite-context
from pathlib import Path
from tinycontext import (
MemoryInput,
TinyContextConfig,
recall_memories,
save_memories,
)
config = TinyContextConfig(
memory_db_path=str(Path("agent-memory.db").resolve()),
recall_max_tokens=800,
)
save_memories(
[
MemoryInput(content="The project uses SQLite for local state.")
],
session_id="project-a",
config=config,
)
result = recall_memories(
"How does the project store state?",
session_id="project-a",
config=config,
)
for memory in result["memories"]:
print(memory["content"])
recent = recall_memories(session_id="project-a", config=config)
Programmatic configuration does not read environment variables or depend on the
checkout. Passing no config uses the per-user data directory returned by
platformdirs.
Docker
Run the published image as an MCP server over Streamable HTTP:
docker compose -f "https://github.com/TinySuiteHQ/TinyContext.git#main:compose.quickstart.yaml" up -d
Connect an MCP client to:
{
"mcpServers": {
"tinycontext": {
"url": "http://localhost:8000/mcp"
}
}
}
The data volume persists /data/memories.db and /data/models.
Hosted multi-user deployment
compose.quickstart.yaml is deliberately a local, single-user example. Do
not expose it directly to multiple users. For an authenticated hosted service,
use compose.hosted.yaml behind a reverse proxy:
export TINYCONTEXT_TENANT_SECRET="a-stable-secret-of-at-least-32-bytes"
export TINYCONTEXT_TRUSTED_PROXY_CIDRS="172.20.0.0/16"
export TINYCONTEXT_TRUSTED_PROXY_TOKEN="$(openssl rand -hex 32)"
docker network create tinycontext-proxy
docker compose -f compose.hosted.yaml up -d
The proxy is the only component on tinycontext-proxy that may reach the
container. It must authenticate the caller, strip any incoming
X-TinyContext-User-Id header, and inject that header with a stable verified
user ID. Set TINYCONTEXT_TRUSTED_PROXY_CIDRS to the proxy's direct Docker or
private-network CIDR. TinyContext rejects requests from other peers and never
accepts a user ID in an MCP tool or API request body.
The proxy also sends X-TinyContext-Proxy-Token: <TINYCONTEXT_TRUSTED_PROXY_TOKEN>
on every request (at least 32 bytes; hosted mode refuses to start without it).
The address alone does not prove a request came from the proxy: anything else
that can send from that network, such as another container or a local program
when TinyContext listens on loopback, could otherwise name any user. A request
from a trusted address with a missing or wrong token is refused like one from
an untrusted address. Keep the token as secret as the proxy's own credentials.
Hosted tenancy stores each user in a separate SQLite file under
TINYCONTEXT_TENANT_STORE_DIR; filenames are HMAC-derived and do not expose
the source user ID. Existing /data/memories.db data is not migrated, because
it has no safe ownership attribution. session_id remains an optional scope
inside a single user's store.
The identity is checked on every MCP message, not once per session. A proxy or chat front end may reuse one MCP session for several users, and each message still lands in the store of the user its own header names.
Management views
A client UI (TinyWebUI's MCP panel, for one) can browse, search, edit and
delete a user's memories through the same MCP connection the tools use. Set
TINYCONTEXT_MANAGEMENT=on, and the server adds MCP resources following the
tinysuite.manage/1 contract: a manifest
(tinycontext://manage/manifest, media type
application/vnd.tinysuite.manage+json) that names the views, and the views
themselves.
- Memories: a paged table with keyword search (the BM25 index recall
uses, ranked best match first), type and order filters, and full detail per
memory. Edits and deletes call the ordinary
update_memoryanddelete_memorytools. - Overview: counts by type, never-recalled memories, and time bounds.
- Service (operators only): store count, disk use, embedding setup.
Every view shows only the caller's own store, under the same rules as the tools. Management is off by default. Over HTTP it also needs an authenticated caller, or the server refuses to start:
- In hosted mode, the trusted proxy's identity opens each caller's own user views, token or not: the proxy has already proven who they are.
TINYCONTEXT_MANAGEMENT_TOKEN(24+ characters), sent asAuthorization: Bearer <token>, opens the Service view, and outside hosted mode every management read. It is the operator's, so a proxy can send it on its own connection only and never on a user's.
A local stdio client is the operator and sees every view.
Stop the service with:
docker compose -f "https://github.com/TinySuiteHQ/TinyContext.git#main:compose.quickstart.yaml" down
For a local image build:
docker compose up -d --build
The optional FastAPI profile uses the same image:
docker compose --profile fastapi up -d --build
- MCP Streamable HTTP:
http://localhost:8000/mcp - FastAPI:
http://localhost:8001
How recall works
flowchart LR
A[Agent] --> B[save_memories]
A --> C[recall_memories]
B --> D[(SQLite)]
C --> D
C --> E[BM25 rank]
C --> G[sqlite-vec cosine rank]
E --> H[Weighted RRF]
G --> H
H --> F[Token budget trim]
F --> A
- Generate embeddings locally with the selected ONNX model.
- Save text, metadata, and float32 embedding BLOBs in the same SQLite row.
- Filter by
session_id, rank lexical matches with BM25, and calculate cosine similarity in SQLite throughsqlite-vec. - Fuse both rankings with weighted reciprocal rank fusion (RRF), normalized to
0..1using the same scoring convention as TinySearch. - Apply the optional normalized RRF cutoff, then return the highest-ranked memories within the count and token budgets.
Relevance labels summarize the normalized hybrid score: high is at least
0.90, medium is at least 0.75, and lower admitted results are low.
Existing TinyContext databases are upgraded in place with nullable embedding columns. The first recall backfills embeddings for legacy rows; no database migration command or separate vector service is required.
Benchmarks
Numbers below come from scripts/benchmark_index_recall_speed.py and
scripts/benchmark_token_savings.py, run against an isolated, throwaway
SQLite store (never a real database) with the default balanced ONNX embedding
model. Reproduce them yourself:
python scripts/benchmark_index_recall_speed.py --checkpoints 100 500 2000 5000 10000 20000 --json-out speed.json
python scripts/benchmark_token_savings.py --json-out savings.json
python scripts/benchmark_recall_accuracy.py --json-out accuracy.json
Write throughput and recall latency
| Corpus size | Write throughput | Recall p50 | Recall p95 |
|---|---|---|---|
| 100 | 170.0 mem/s | 8.9ms | 9.9ms |
| 500 | 210.3 mem/s | 9.0ms | 10.1ms |
| 2,000 | 208.2 mem/s | 10.5ms | 12.3ms |
| 5,000 | 204.3 mem/s | 10.8ms | 12.6ms |
| 10,000 | 180.5 mem/s | 11.0ms | 12.3ms |
| 20,000 | 186.5 mem/s | 11.4ms | 12.5ms |
Recall stays flat well past a few thousand memories: p95 only grows from 9.9ms to 12.5ms across a 200x increase in corpus size (100 to 20,000). Each retriever (BM25, dense) hands over its own top-scoring candidates rather than every stored memory being hydrated and ranked on each call; only that bounded, unioned pool is fused and scored. There's still no ANN index underneath — SQLite has to evaluate every candidate row to find those top-scoring matches, so this is bounded brute force rather than sublinear search, and will eventually bend upward again well beyond the sizes tested here. Write throughput holds steady regardless of corpus size.
Token savings vs. a naive "resend everything" agent
Against 300 synthetic memories and 8 queries: 96.7% fewer tokens than concatenating every stored memory raw, or roughly $16.42 saved per 1,000 recalls at $3/MTok input pricing (Claude Sonnet 5).
How this compares to the market
Published numbers from Mem0 (~90%+ token reduction, ~200ms p95 latency) and Zep (~65–200ms p95 latency) put TinyContext at or ahead on token compaction, and ahead on latency at the corpus sizes tested here (single-digit-to-low-teens ms p95 vs. 65-200ms). That's not an apples-to-apples claim, though — those figures come from real conversational benchmarks (LoCoMo, LongMemEval) with retrieval-accuracy grading in the loop, run against hosted vector databases at larger scale than tested above.
Retrieval accuracy — an open question, not a claim
scripts/benchmark_recall_accuracy.py plants 15 distinct facts inside a
growing pool of filler memories and queries each with a paraphrase, checking
whether hybrid recall returns the right memory id. Locally this comes back
at 100% recall@k and MRR 1.00 from 100 up to 5,000 filler memories — but
the planted facts are semantically distinct from the filler, so this mostly
shows the mechanism works, not that it holds up against confusable,
near-duplicate memories or a real labeled benchmark like LoCoMo/LongMemEval.
This is the one number here we're not standing behind as-is. If you run a harder or larger-scale accuracy eval against TinyContext — adversarial near-duplicates, a real conversational dataset, whatever — we'd genuinely like to see it, good or bad. Open an issue or a PR with what you found.
LoCoMo and LongMemEval (retrieval only)
scripts/benchmark_locomo.py and scripts/benchmark_longmemeval.py run
TinyContext against the two standard conversational-memory datasets, grading
whether recall_memories returns the turns or sessions the dataset labels as
evidence, within the configured token budget and top-k. They use no LLM, so the
results are deterministic and need no API key. Datasets are downloaded to
.cache/benchmarks/ on first run.
These are retrieval metrics, not the LLM-judged answer accuracy that Mem0, Zep and Letta publish, so they are not directly comparable to those figures.
python scripts/benchmark_locomo.py --json-out scripts/benchmark_locomo.latest.json
python scripts/benchmark_longmemeval.py --limit 50 --json-out scripts/benchmark_longmemeval.latest.json
Results: not yet run.
FastAPI
The optional HTTP API mirrors the MCP tools.
| Method | Path | Purpose |
|---|---|---|
| GET | /health |
Liveness |
| POST/GET | /save_memories |
Persist one or more memories |
| POST/GET | /recall_memories |
Recall memories within a token budget: semantically ranked with a query, or newest-first without one |
| POST/GET | /list_memories |
Browse memories newest-first with pagination and an optional since/until date range; no ranking, no token-budget cutoff |
| POST/GET | /get_memory |
Fetch one memory's full content by id/ref |
| POST | /update_memory |
Supersede a memory with corrected content |
| POST | /delete_memory |
Delete a single memory by id |
Install and run it directly:
pip install "tinysuite-context[server]"
uvicorn tinycontext.servers.fastapi_server:app --host 0.0.0.0 --port 8000
When TINYCONTEXT_TENANCY=proxy-header is enabled, these endpoints require
the same trusted-proxy identity as hosted MCP. The health endpoint remains
available for liveness checks.
Save request
{
"session_id": "optional-session",
"memories": [
{
"content": "User prefers concise answers"
},
{
"content": "Call the user Marcell",
"kind": "profile"
}
]
}
kind defaults to "episodic". Items with kind: "profile" are stored
globally (ignoring session_id) and returned in every recall response's
profile field rather than memories.
Recall request
{
"query": "user preferences",
"session_id": "optional-session",
"max_tokens": 2000,
"top_k": 10
}
Recent recall request
Omit query (or send it blank) to switch /recall_memories into chronological
mode:
{
"session_id": "optional-session",
"top_k": 5
}
This also accepts GET /recall_memories?session_id=optional-session&top_k=5.
The response uses mode: "recent" and contains only durable memory fields,
recency ranks, timestamps, token counts, and the configured token-budget result.
List request
{
"since": "2026-08-18T00:00:00Z",
"until": "2026-08-25T00:00:00Z",
"limit": 20,
"offset": 0
}
limit defaults to 20 (capped at 200). The response is newest-first and
includes total_count, returned_count, and has_more for pagination, plus
a preview_truncated flag per entry (content is truncated to a short
preview; fetch the rest with /get_memory). This also accepts
GET /list_memories?since=...&until=...&limit=...&offset=.... Add
search (up to 200 characters) to keep only keyword matches from the BM25
index recall uses: every word must appear, and the last may be a prefix
(pyth finds python). Searched results default to sort=relevance, best
match first; recent and stale still apply.
Get request
{
"memory_id": "fee1180f1c8f"
}
Also accepts GET /get_memory?memory_id=fee1180f1c8f. Returns the memory's
full, untruncated content plus its lifecycle fields (recall_count,
last_recalled_at, superseded_by).
Error codes
| Code | HTTP | Meaning |
|---|---|---|
empty_memory |
400 | Missing or blank memory content/query |
session_not_found |
404 | No memories exist for the requested session |
recall_budget |
400 | Invalid recall budget parameters |
memory_not_found |
404 | No memory matches the given ref or id |
ambiguous_memory_reference |
409 | A short ref matches more than one memory |
memory_already_superseded |
409 | The memory was already replaced by update_memory |
invalid_memory_kind |
400 | kind is not episodic or profile |
invalid_sort |
400 | sort is not recent, stale, or (with search) relevance |
invalid_filter |
400 | search is longer than 200 characters |
unauthorized |
401 | Hosted request lacks a valid trusted-proxy identity |
internal_error |
500 | Unexpected server error |
TinyContext MCP questions
How do I add TinyContext MCP to Claude Code?
Run claude mcp add --env 'OTEL_EXPORTER_OTLP_HEADERS=<YOUR_OTEL_EXPORTER_OTLP_HEADERS>' tinycontext -- docker run -i --rm docker.io/marcellm01/tinycontext:v0.5.4 in your terminal. Add --scope user to make it available in every project.
How do I add TinyContext MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
How does TinyContext handle memory retrieval?
It stores memories and embeddings in SQLite, ranking them using a hybrid of BM25 and dense retrieval to fit within a specified token budget.
Can I use TinyContext without a hosted account or a large vector database?
Yes, it is designed to work locally without a hosted account or the requirement of a separate giant vector database.