Skip to main content
Glama

Tessera

PyPI version Downloads Tests Python License Website

Every AI conversation produces knowledge. When the session ends, it's gone. Tessera keeps it.

One knowledge base for Claude Desktop, with an HTTP API for scripts and automation. Runs locally. No API keys, no Docker, no data leaving your machine.

pip install project-tessera
tessera setup
# Done. Claude Desktop now has persistent memory + document search.

Why Tessera over alternatives

Tessera

Mem0

Basic Memory

mcp-memory-service

Works without API keys

Yes

No (needs OpenAI)

Yes

Partial

Works without Docker

Yes

No

Yes

No

Document search (40+ types)

Yes

No

Markdown only

No

ChatGPT integration (via tunnel)

Yes

No

No

No

Contradiction detection

Yes

No

No

No

Memory confidence scoring

Yes

No

No

No

Encrypted vault (AES-256)

Yes

No

No

No

HTTP API for non-MCP tools

58 endpoints

Yes

No

Yes

Auto-learning from conversations

Yes

Yes

No

No

MCP tools

58

~10

~15

24

The short version

Most memory tools store text and search it. Tessera does that, plus:

  • HTTP API: 58 REST endpoints let scripts, ChatGPT (via tunnel + Custom GPT Actions), and local LLMs read and write the same knowledge base.

  • Self-maintaining: finds contradictions between old and new memories, scores confidence by reinforcement frequency, flags stale knowledge, auto-merges near-duplicates.

  • Zero infrastructure: pip install and go. LanceDB and fastembed are embedded -- no Docker, no database server, no API keys.

  • Encrypted: set TESSERA_VAULT_KEY and all memories are AES-256-CBC encrypted at rest.


Related MCP server: MCP VectorStore Server

Architecture

How search works (query path)

    User asks: "What did we decide about the database?"
                            |
                            v
                +-----------------------+
                |    Query Processing   |
                |  Multi-angle decomp   |    "database decision"
                |  (2-4 perspectives)   |    "database", "decision"
                +-----------------------+    "decision about database"
                            |
              +-------------+-------------+
              |                           |
              v                           v
    +------------------+        +------------------+
    |  Vector Search   |        |  Keyword Search  |
    |  (LanceDB)       |        |  (FTS index)     |
    |  384-dim MiniLM  |        |  BM25 scoring    |
    +------------------+        +------------------+
              |                           |
              +-------------+-------------+
                            |
                            v
                +-----------------------+
                |      Reranking        |
                |  70% semantic weight  |    LinearCombinationReranker
                |  30% keyword weight   |    + version-aware scoring
                +-----------------------+
                            |
                            v
                +-----------------------+
                |   Result Assembly     |
                |  Dedup (content hash) |    2-pass deduplication
                |  Verdict labels       |    found / weak / none
                |  Cache (60s TTL)      |
                +-----------------------+
                            |
                            v
                    Top-K results with
                    confidence scores

How ingestion works (ingest path)

    Documents: .md .pdf .docx .xlsx .py .ts .go ...  (40+ types)
                            |
                            v
                +-----------------------+
                |   File Type Router    |
                |  Markdown, CSV, XLSX  |    Type-specific parsers
                |  Code, PDF, Images    |    with metadata extraction
                +-----------------------+
                            |
                            v
                +-----------------------+
                |   Chunking Engine     |
                |  1024 tokens/chunk    |    Sentence-boundary aware
                |  100 token overlap    |    Heading-preserving
                +-----------------------+
                            |
                            v
                +-----------------------+
                |   Local Embedding     |
                |  fastembed/ONNX       |    paraphrase-multilingual
                |  384 dimensions       |    MiniLM-L12-v2
                |  No API calls         |    101 languages
                +-----------------------+
                            |
              +-------------+-------------+
              |                           |
              v                           v
    +------------------+        +------------------+
    |    LanceDB       |        |     SQLite       |
    |  Vector storage  |        |  File metadata   |
    |  Columnar format |        |  Search analytics|
    |  Zero-config     |        |  Interaction log |
    +------------------+        +------------------+

System overview

                    +--------------------------------------------+
                    |              src/core.py                    |
                    |         58 orchestration functions          |
                    |   69 specialized modules, 31k LOC           |
                    +--------------------------------------------+
                     /                |                \
    +---------------+  +-------------------+  +--------------+
    | MCP Server    |  | HTTP API Server   |  | CLI          |
    | Claude Desktop|  | FastAPI + Swagger |  | 11 commands  |
    | 58 tools      |  | 58 endpoints      |  | setup, sync  |
    | stdio         |  | port 8394         |  | ingest, api  |
    +---------------+  +-------------------+  +--------------+
           |                    |                     |
           v                    v                     v
    +------------------------------------------------------------+
    |                    Storage Layer                            |
    |  LanceDB         SQLite           Filesystem               |
    |  (vectors)       (metadata,       (memories as .md,        |
    |                   analytics,       encrypted with           |
    |                   interactions)    AES-256-CBC)             |
    |                                                            |
    |  fastembed/ONNX: local embedding, no API keys              |
    |  101 languages, 384-dim vectors, ~220MB model              |
    +------------------------------------------------------------+

Get started

1. Install

pip install project-tessera

Or with uv:

uvx --from project-tessera tessera setup

2. Setup

tessera setup

Creates workspace config, downloads embedding model (~220MB, first time only), configures Claude Desktop.

3. Restart Claude Desktop

Ask Claude about your documents. It searches automatically.

Use with ChatGPT (Custom GPT Actions)

tessera api                     # Start REST API on localhost:8394
ngrok http 8394                 # Expose to the internet
# Then create a Custom GPT with the Actions spec from /chatgpt-actions/openapi.json

Full setup guide at http://127.0.0.1:8394/chatgpt-actions/setup. Swagger docs at http://127.0.0.1:8394/docs.


How it works

Hybrid search with reranking

Every search goes through four stages:

  1. Query decomposition -- the query is split into 2-4 search angles (core keywords, individual terms, reversed emphasis)

  2. Hybrid retrieval -- vector similarity (LanceDB) and keyword matching (FTS/BM25) run in parallel

  3. Reranking -- a LinearCombinationReranker merges the two result sets (70% semantic, 30% keyword weight)

  4. Verdict scoring -- each result gets a label: confident match (>= 45%), possible match (25-45%), or low relevance (< 25%)

When multiple versions of the same document exist, Tessera prefers the latest.

Cross-session memory

# Via MCP (Claude)
"Remember that we chose PostgreSQL for the production database"

# Via HTTP API (scripts, local LLMs, ChatGPT via tunnel)
curl -X POST http://127.0.0.1:8394/remember \
  -H "Content-Type: application/json" \
  -d '{"content": "Use PostgreSQL for production", "tags": ["db", "architecture"]}'

Each memory gets a category (decision, preference, or fact), is checked for duplicates against existing memories (cosine similarity, 0.92 threshold), and receives a confidence score -- weighted by repetition (35%), recency (25%), source diversity (20%), and category (20%). Set TESSERA_VAULT_KEY to encrypt all memories with AES-256-CBC.

Auto-learning

Tessera picks up decisions, preferences, and facts from your conversations without being asked. toggle_auto_learn turns it on or off; review_learned shows what it caught.

Contradiction detection

Memories contradict each other over time. Tessera finds them:

CONTRADICTION (HIGH severity):
  "We decided to use PostgreSQL" (2026-03-01)
  vs
  "Switched to MongoDB for the main database" (2026-03-10)

  The newer memory (2026-03-10) likely reflects the current state.

Works with both English and Korean negation patterns.

ChatGPT integration (requires tunnel)

ChatGPT can talk to Tessera through Custom GPT Actions, but since ChatGPT's servers need to reach your machine, you need a tunnel (ngrok, Cloudflare Tunnel, etc.) to expose your local API.

Requirements: Your computer must be on, the API server running, and the tunnel active. When any of these stop, ChatGPT loses access.

# 1. Start Tessera API + tunnel
tessera api
ngrok http 8394   # or: cloudflared tunnel --url http://localhost:8394

# 2. Get the OpenAPI spec for your Custom GPT
curl https://your-tunnel-url/chatgpt-actions/openapi.json?server_url=https://your-tunnel-url

# 3. Get the GPT instruction template
curl https://your-tunnel-url/chatgpt-actions/instructions

Create a Custom GPT, paste the instructions, import the OpenAPI spec as an Action.

You can also import past ChatGPT conversations to extract knowledge from them:

curl -X POST http://127.0.0.1:8394/import-conversations \
  -H "Content-Type: application/json" \
  -d '{"data": "<ChatGPT export JSON>", "source": "chatgpt"}'

Export as Obsidian vault (wikilinks), Markdown, CSV, or JSON:

curl http://127.0.0.1:8394/export?format=obsidian

Memory health

Each memory is healthy, stale (90+ days without reinforcement), or orphaned (no metadata, no category). The health report tells you what to clean up and tracks growth over time.

Plugin hooks

Run your own scripts when things happen:

# workspace.yaml
hooks:
  on_memory_created:
    - script: ./notify-slack.sh
  on_contradiction_found:
    - script: ./alert.py

7 event types: on_memory_created, on_memory_deleted, on_search, on_session_start, on_session_end, on_ingest_complete, on_contradiction_found.


Supported file types (40+)

Category

Extensions

Install

Documents

.md .txt .rst .csv

included

Office

.xlsx .docx .pdf

pip install project-tessera[xlsx,docx,pdf]

Code

.py .js .ts .tsx .jsx .java .go .rs .rb .php .c .cpp .h .swift .kt .sh .sql .cs .dart .r .lua .scala

included

Config

.json .yaml .yml .toml .xml .ini .cfg .env

included

Web

.html .htm .css .scss .less .svg

included

Images

.png .jpg .jpeg .webp .gif .bmp .tiff

pip install project-tessera[ocr]


MCP tools (58)

Tool

What it does

search_documents

Semantic + keyword hybrid search across all docs

unified_search

Search documents AND memories in one call

view_file_full

Full file view (CSV as table, XLSX per sheet)

read_file

Read any file's full content

list_sources

See what's indexed

Tool

What it does

remember

Save knowledge that persists across sessions

recall

Search past memories with date/category filters

learn

Save and immediately index new knowledge

list_memories

Browse saved memories

forget_memory

Delete a specific memory

export_memories

Batch export all memories as JSON

import_memories

Batch import memories from JSON

memory_tags

List all unique tags with counts

search_by_tag

Filter memories by specific tag

memory_categories

List auto-detected categories (decision/preference/fact)

search_by_category

Filter memories by category

find_similar

Find documents similar to a given file

knowledge_graph

Build a Mermaid diagram of document relationships

Tool

What it does

digest_conversation

Extract and save knowledge from the current session

toggle_auto_learn

Turn auto-learning on/off or check status

review_learned

Review recently auto-learned memories

session_interactions

View tool calls from current/past sessions

recent_sessions

Session history with interaction counts

Tool

What it does

decision_timeline

How your decisions changed over time, by topic

context_window

Pack the best context into a token budget

smart_suggest

Query suggestions based on your past searches

topic_map

Cluster memories by topic with Mermaid mindmap

knowledge_stats

Aggregate statistics (categories, tags, growth)

user_profile

Auto-built profile (language, preferences, expertise)

explore_connections

Show connections around a specific topic

Tool

What it does

deep_search

Breaks a query into 2-4 angles, searches each, merges best results

deep_recall

Multi-angle memory recall with verdict labels

detect_contradictions

Find conflicting memories with severity rating

memory_confidence

How reliable is each memory (repetition, recency, source diversity)

memory_health

Which memories are healthy, stale, or orphaned

list_plugin_hooks

See what hooks are registered

Tool

What it does

export_for_ai

Export memories in portable format

import_from_ai

Import memories from external sources

import_conversations

Extract knowledge from ChatGPT/Claude conversation exports

export_knowledge

Export as Obsidian (wikilinks), Markdown, CSV, or JSON

ChatGPT can connect via Custom GPT Actions (requires tunnel). See /chatgpt-actions/setup.

Tool

What it does

vault_status

Check AES-256 encryption status

migrate_data

Upgrade data from older schema versions

Tool

What it does

ingest_documents

Index documents (first-time or full rebuild)

sync_documents

Incremental sync (only changed files)

project_status

Recent changes per project

extract_decisions

Find past decisions from logs

audit_prd

Check PRD quality (13-section structure)

organize_files

Move, rename, archive files

suggest_cleanup

Detect backup files, empty dirs, misplaced files

tessera_status

Server health: tracked files, sync history, cache

health_check

Full workspace diagnostics

search_analytics

Search usage patterns, top queries, response times

check_document_freshness

Detect stale documents older than N days


HTTP API (58 endpoints)

pip install project-tessera[api]
tessera api  # http://127.0.0.1:8394

Swagger UI at http://127.0.0.1:8394/docs. Optional auth via TESSERA_API_KEY env var.

Method

Path

What it does

GET

/health

Health check

GET

/version

Version info

POST

/search

Semantic + keyword search

POST

/unified-search

Search docs + memories

POST

/remember

Save a memory

POST

/recall

Search memories with filters

POST

/learn

Save and index knowledge

GET

/memories

List memories

DELETE

/memories/{id}

Delete a memory

GET

/memories/categories

List categories

GET

/memories/search-by-category

Filter by category

GET

/memories/tags

List tags

GET

/memories/search-by-tag

Filter by tag

POST

/context-window

Build token-budgeted context

GET

/decision-timeline

Decision evolution

GET

/smart-suggest

Query suggestions

GET

/topic-map

Topic clusters

GET

/knowledge-stats

Stats dashboard

POST

/batch

Multiple operations in one call

GET

/export

Export as Obsidian/MD/CSV/JSON

GET

/export-for-ai

Export memories in portable format

POST

/import-from-ai

Import memories from external sources

POST

/import-conversations

Import past conversations

POST

/migrate

Run data migration

GET

/vault-status

Encryption status

GET

/user-profile

User profile

GET

/status

Server status

GET

/health-check

Workspace diagnostics

POST

/deep-search

Multi-angle document search

POST

/deep-recall

Multi-angle memory recall

GET

/contradictions

Detect conflicting memories

GET

/memory-confidence

Memory reliability scores

GET

/memory-health

Memory health analytics

GET

/hooks

List plugin hooks

GET

/entity-search

Search entity knowledge graph

POST

/entity-graph

Mermaid diagram from entities

GET

/consolidation-candidates

Find similar memory clusters

POST

/consolidate

Merge similar memories

GET

/dashboard

Web dashboard (dark theme, entity graph, stats)

POST

/sleep-consolidate

Auto-merge near-duplicate memories

POST

/retention-policy

Flag old or low-quality memories

GET

/retention-summary

Age distribution and at-risk counts

GET

/adapters/{framework}

Setup code for LangChain, CrewAI, AutoGen

POST

/auto-curate

Classify, tag, deduplicate, and clean up memories

GET

/auto-insights

Trending topics, decision patterns, hidden connections

GET

/chatgpt-actions/openapi.json

OpenAPI spec for Custom GPT Actions

GET

/chatgpt-actions/instructions

GPT instruction template

GET

/chatgpt-actions/setup

ChatGPT integration setup guide

Quick examples

# Search documents
curl -X POST http://127.0.0.1:8394/search \
  -H "Content-Type: application/json" \
  -d '{"query": "database architecture", "top_k": 5}'

# Save a memory
curl -X POST http://127.0.0.1:8394/remember \
  -H "Content-Type: application/json" \
  -d '{"content": "Use PostgreSQL for production", "tags": ["db"]}'

# Export memories
curl http://127.0.0.1:8394/export-for-ai?target=chatgpt

# Batch (multiple operations, single request)
curl -X POST http://127.0.0.1:8394/batch \
  -H "Content-Type: application/json" \
  -d '{"operations": [{"method": "search", "params": {"query": "test"}}, {"method": "knowledge_stats"}]}'

CLI (11 commands)

tessera setup          # One-command setup (config + model download + Claude Desktop)
tessera init           # Interactive setup
tessera ingest         # Index all document sources
tessera sync           # Re-index changed files only
tessera serve          # Start MCP server (stdio)
tessera api            # Start HTTP API server (port 8394)
tessera migrate        # Upgrade data schema
tessera check          # Workspace health diagnostics
tessera status         # Project status summary
tessera install-mcp    # Configure Claude Desktop
tessera version        # Show version

Claude Desktop config

With uvx (recommended):

{
  "mcpServers": {
    "tessera": {
      "command": "uvx",
      "args": ["--from", "project-tessera", "tessera-mcp"]
    }
  }
}

With pip:

{
  "mcpServers": {
    "tessera": {
      "command": "tessera-mcp"
    }
  }
}

Config location:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json


Configuration

tessera setup creates workspace.yaml:

workspace:
  root: /Users/you/Documents
  name: my-workspace

sources:
  - path: .
    type: document

search:
  reranker_weight: 0.7     # Semantic vs keyword balance (0.0 = keyword only, 1.0 = vector only)
  max_top_k: 50            # Max results per search

ingestion:
  chunk_size: 1024         # Tokens per chunk
  chunk_overlap: 100       # Overlap between chunks

hooks:                      # Optional plugin hooks
  on_memory_created:
    - script: ./my-hook.sh

Or set TESSERA_WORKSPACE=/path/to/docs to skip config file entirely.

Environment variables:

  • TESSERA_API_KEY -- enable API authentication

  • TESSERA_VAULT_KEY -- enable AES-256 encryption for memories


Technical details

Component

Technology

Why

Vector store

LanceDB

Embedded columnar store. No server process, handles vector + metadata queries natively

Embeddings

fastembed/ONNX

Local inference, no API keys. paraphrase-multilingual-MiniLM-L12-v2 (384-dim, 101 languages)

Metadata

SQLite

File tracking, search analytics, interaction logging. Thread-safe with reentrant locks

Memory storage

Filesystem (.md)

Human-readable, git-friendly, encryptable. YAML frontmatter for metadata

Encryption

Pure Python AES-256-CBC

No OpenSSL dependency. PKCS7 padding, random IV per memory

HTTP API

FastAPI

Swagger docs, Pydantic validation, async-capable

MCP

FastMCP (stdio)

Standard MCP protocol for Claude Desktop

Numbers

Metric

Count

MCP tools

58

HTTP endpoints

58

CLI commands

11

Core modules

69

Lines of code

31,000+

Tests

1102

File types

40+


License

AGPL-3.0 -- see LICENSE.

Commercial licensing: bessl.framework@gmail.com

Available Tools

58 tools
assign_memory_projectB

Assign a memory to a project space. Use this to organize memories by project context (e.g., 'tessera', 'frontend-app', 'api-design').

Inputs: memory_id (required), project (required). Returns: result

audit_prdA

Audit a PRD file for quality and completeness against a 13-section structure. Checks section coverage, Mermaid syntax, wireframes, versioning, and changelog.

check_sprawl=True: Detect multiple versions of the same PRD (suggest archiving old ones) check_consistency=True: Check cross-PRD consistency for period selectors and tiers

Inputs: file_path (required), check_sprawl, check_consistency. Returns: result

check_document_freshnessA

Check for stale/outdated documents that haven't been modified recently. Returns a list grouped by project showing file names and days since last update. Use this proactively to suggest document reviews.

Inputs: days_threshold. Returns: result

context_windowA

Build an optimal context window for a query within a token budget. Retrieves relevant memories and documents, assembles them in priority order, and truncates to fit. Use this to prepare context for another AI tool.

Inputs: query (required), token_budget, include_documents. Returns: result

decision_timelineB

Show decision timeline — how decisions evolved over time, grouped by topic. Detects when you changed your mind about something.

Inputs: no named parameters. Returns: result

deep_recallB

Search memories using multiple query angles for better recall. Like deep_search but for memories. Decomposes the query into multiple perspectives and merges results. Each result includes a confidence verdict. Use when recall misses relevant memories.

Inputs: query (required), top_k, since, until, +1 more. Returns: result

detect_contradictionsA

Detect contradictions among your stored memories. Finds decisions, preferences, or facts that conflict with each other. Shows severity (HIGH/MEDIUM) and which memory is newer. Use periodically to keep your knowledge base consistent.

Inputs: no named parameters. Returns: result

digest_conversationA

Digest the current conversation: extract decisions, preferences, and facts from this session's interactions and save them as memories automatically. Call this at the end of a conversation to preserve important knowledge. You can also pass a summary text to extract facts from.

Inputs: summary. Returns: result

explore_connectionsB

Show connections for a specific document or concept in the knowledge graph. Returns related documents, shared topics, and a focused Mermaid subgraph.

Inputs: query (required), top_k. Returns: result

export_for_aiA

Export memories for use in another AI tool. Supported targets: 'chatgpt' (ChatGPT memory JSON), 'gemini' (Gemini context format), 'standard' (Tessera interchange format). Use this when migrating knowledge to another AI platform.

Inputs: target. Returns: result

export_knowledgeA

Export all your knowledge in various formats. Supported formats: 'markdown' (default), 'obsidian' (with wikilinks and frontmatter), 'csv' (spreadsheet-compatible), 'json' (machine-readable). Use 'obsidian' to import into Obsidian vaults.

Inputs: format. Returns: result

export_memoriesA

Export all saved memories as JSON for backup or transfer. Returns a JSON string with all memories and their metadata.

Inputs: no named parameters. Returns: result

extract_decisionsC

Extract decisions from session logs and decision logs. Call automatically when asked about past decisions.

Inputs: project_id, since. Returns: result

find_similarB

Find documents similar to a given document. Returns related documents ranked by similarity. Use this when users ask 'what else is related to this document'.

Inputs: source_path (required), top_k. Returns: result

forget_memoryA

Delete a specific memory by filename (without .md extension). Use list_memories first to find the memory to delete.

Inputs: memory_name (required). Returns: result

health_checkB

Run a comprehensive health check on the Tessera workspace. Checks: config validity, dependencies, index status, stale documents, zero-result query patterns. Returns actionable recommendations.

Inputs: no named parameters. Returns: result

import_conversationsA

Import past conversations from ChatGPT, Claude, or Gemini exports. Paste the exported JSON data and specify the source: 'chatgpt', 'claude', 'gemini', or 'text'. Tessera extracts decisions, preferences, and facts from the conversations. Use this to recover knowledge from past AI interactions.

Inputs: data (required), source. Returns: result

import_from_aiB

Import memories from another AI tool. Paste the exported JSON data and specify the source: 'chatgpt', 'gemini', or 'standard'. Memories will be automatically categorized and stored in Tessera.

Inputs: data (required), source. Returns: result

import_memoriesB

Import memories from a JSON string (batch import). Format: [{"content": "...", "tags": ["..."], "source": "..."}]. Use export_memories to get the expected format.

Inputs: data (required). Returns: result

ingest_documentsA

Index (or re-index) all workspace documents into the vector store. Run this when setting up Tessera for the first time, or when you want to rebuild the entire index from scratch. Optionally pass specific directory paths to index only those.

Inputs: paths. Returns: result

knowledge_graphA

Build a knowledge graph from indexed documents showing relationships between concepts, decisions, and entities. Returns a Mermaid diagram of the document relationships.

scope: 'project' (single project) or 'all' (entire workspace) max_nodes: limit the number of nodes in the graph (default 30)

Inputs: query, project, scope, max_nodes. Returns: result

knowledge_statsB

Get knowledge statistics — total memories, category breakdown, tag distribution, growth by month, and date range. A dashboard overview of everything Tessera knows.

Inputs: no named parameters. Returns: result

learnA

Auto-learn: save new knowledge and immediately index it for search. Use this to capture insights, patterns, or facts discovered during conversation.

Inputs: content (required), tags, source. Returns: result

list_memoriesB

List saved memories with optional filtering. Use to browse what Tessera has remembered across sessions.

Inputs: limit. Returns: result

list_plugin_hooksA

List all registered plugin hooks. Shows which events have hooks attached and what scripts/functions will be called. Configure hooks in workspace.yaml under 'hooks:' section.

Inputs: no named parameters. Returns: result

list_projectsB

List all project spaces with memory counts, latest activity, and top tags. Shows how knowledge is distributed across projects.

Inputs: no named parameters. Returns: result

list_sourcesB

List all indexed source files.

Inputs: no named parameters. Returns: result

memory_categoriesA

List all memory categories with counts. Categories are auto-detected: decision, preference, fact, reference, context.

Inputs: no named parameters. Returns: result

memory_confidenceA

Analyze confidence scores for all memories. Rates each memory based on repetition (confirmed by other memories), source diversity, recency, and category stability. Returns high-confidence memories you can trust and low-confidence ones that may need review.

Inputs: no named parameters. Returns: result

memory_healthA

Analyze memory health: classify all memories as healthy, stale (90+ days old), or orphaned (minimal metadata). Returns a health score, breakdown, recommendations for cleanup, and growth statistics over time.

Inputs: no named parameters. Returns: result

memory_lineageA

Trace the provenance lineage of a memory — where it came from, which session created it, and what parent memories it was derived from.

Inputs: memory_id (required). Returns: result

memory_tagsA

List all unique tags across saved memories with their counts. Useful for browsing memory categories.

Inputs: no named parameters. Returns: result

migrate_dataA

Migrate Tessera data to the latest schema version. Creates a backup before migration. Use dry_run=True to preview changes. Handles v0.6.x through v1.0.0 data format upgrades.

Inputs: dry_run. Returns: result

organize_filesA

Organize files in the workspace. action: 'move', 'archive', 'rename', 'list'. Always call suggest_cleanup first and get user confirmation before organizing.

Inputs: action (required), path (required), destination, new_name, +1 more. Returns: result

project_statusA

Get project status including HANDOFF.md, recent changes, and file statistics. Call automatically when asked about project status.

Inputs: project_id. Returns: result

provenance_statsA

Get aggregate provenance statistics — how many memories have provenance, breakdown by source type and session.

Inputs: no named parameters. Returns: result

read_fileB

Read file contents by absolute path.

Inputs: file_path (required). Returns: result

recallA

Search past memories from previous sessions. Call this when the user asks 'what did I say about...', 'do you remember...', or references past conversations.

Supports time filters (since/until as ISO date, e.g. '2026-03-01') and category filter (decision/preference/fact).

Inputs: query (required), top_k, since, until, +2 more. Returns: result

recent_sessionsA

View summary of recent sessions — when they started, ended, and how many tool calls were made. Useful for understanding usage patterns over time.

Inputs: limit. Returns: result

rememberA

Save a piece of knowledge for cross-session persistence. Use this when the user says 'remember this' or when important decisions, preferences, or facts should be preserved across conversations.

Inputs: content (required), tags, project. Returns: result

review_learnedC

Review recently auto-learned memories. Shows memories created by auto-extract, digest, or session summary.

Inputs: limit. Returns: result

search_analyticsB

Show search usage analytics: total queries, top queries, zero-result queries, response times, and daily trends. Use for understanding search patterns.

Inputs: days. Returns: result

search_by_categoryA

Search memories by category (e.g. 'decision', 'preference', 'fact'). Use memory_categories first to see available categories.

Inputs: category (required). Returns: result

search_by_tagA

Search memories by a specific tag. Use memory_tags first to see available tags.

Inputs: tag (required). Returns: result

search_documentsA

Hybrid (semantic + keyword) search across indexed workspace documents (PRDs, decision logs, session logs, etc.). Call this tool first when the user asks about project-related content.

Filter by project ID or doc_type (prd, session_log, decision_log, document).

Inputs: query (required), top_k, project, doc_type. Returns: result

session_interactionsB

View what happened in the current or past sessions. Shows tool calls, queries, and results — useful for reviewing what was discussed and decided.

Inputs: session_id, limit. Returns: result

session_primeA

Get a session-start context briefing with recent decisions, preferences, active topics, and last session summary. Call this at the beginning of a conversation to prime your context with the user's recent knowledge.

Inputs: days. Returns: result

smart_suggestB

Get personalized query suggestions based on your past searches and memories. Analyzes patterns to recommend what you might want to explore next.

Inputs: max_suggestions. Returns: result

suggest_cleanupB

Generate cleanup suggestions for the workspace. Detects root-level files, backup files, large files, empty directories. Call this tool first when cleanup is requested.

Inputs: path. Returns: result

sync_documentsA

Incrementally sync the index with your workspace. Only processes new, changed, or deleted files since the last sync. Much faster than full ingestion. Run this when you've updated some documents.

Inputs: no named parameters. Returns: result

tessera_statusA

Show Tessera server health: tracked files, sync history, index size, cache stats, and watcher status. Call this when asked about server status or troubleshooting.

Inputs: no named parameters. Returns: result

toggle_auto_learnA

Toggle or check auto-learning status. When enabled, Tessera automatically extracts decisions, preferences, and facts from conversations. Call without arguments to check status.

Inputs: enabled. Returns: result

topic_mapB

Generate a topic map showing how your knowledge is organized. Clusters memories by shared keywords and shows topic distribution. Use format='mermaid' for a visual Mermaid mindmap diagram.

Inputs: output_format. Returns: result

user_profileB

View your user profile — preferences, decisions, top topics, language preference, tool usage patterns, and knowledge areas.

Inputs: no named parameters. Returns: result

vault_statusA

Check vault encryption status. When TESSERA_VAULT_KEY is set, memories are encrypted at rest using AES-256-CBC. All encryption is local — no cloud, no external services.

Inputs: no named parameters. Returns: result

view_file_fullA

Return full contents of a file as a structured view. CSV → markdown table, XLSX → tables per sheet, MD → raw text, DOCX → paragraphs. Use when the user wants to see the complete file, not just search results.

Inputs: file_path (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 58 tools

    Disambiguation2/5

    Many tools have overlapping purposes that could cause confusion. For example, deep_search and deep_recall both perform multi-angle searches but target documents vs. memories, while unified_search combines both; search_documents, search_by_category, search_by_tag, and find_similar all search with different filters; and export_for_ai, export_knowledge, and export_memories all export data in various formats. The descriptions help clarify, but the sheer number of overlapping tools makes disambiguation challenging.

    Naming Consistency4/5

    Tool names follow a consistent snake_case pattern throughout, with clear verb_noun structures (e.g., assign_memory_project, audit_prd, check_document_freshness). There are minor deviations like context_window (noun_noun) and health_check (noun_verb), but overall the naming is predictable and readable.

    Tool Count2/5

    With 58 tools, the count is excessive for a knowledge management server, leading to bloat and potential confusion. Many tools could be consolidated (e.g., multiple export/search variants) without losing functionality. This overwhelms the scope and makes the toolset feel heavy and difficult to navigate.

    Completeness5/5

    The toolset provides comprehensive coverage for knowledge management, including ingestion (import/ingest), storage (remember/assign), retrieval (search/recall), analysis (detect_contradictions/knowledge_graph), export (various formats), and maintenance (health_check/cleanup). It supports full CRUD operations on memories and documents, with no obvious gaps in the domain's lifecycle.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that transforms codebases into knowledge graphs using Neo4J, enabling AI assistants to understand code structure, relationships, and metrics for more context-aware assistance.
      28
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides advanced document search and processing capabilities through vector stores, including PDF processing, semantic search, web search integration, and file operations. Enables users to create searchable document collections and retrieve relevant information using natural language queries.
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables real-time indexing and semantic search of local documents (PDF, Word, text, Markdown, RTF) using vector embeddings and local LLMs. Monitors folders for changes and provides natural language search capabilities through Claude Desktop integration.
      22
      MIT
    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      Turns Claude Desktop into a personal document question-answering system using local vector search. Index PDF, TXT, and Markdown documents into collections and get answers based strictly on your documents with zero hallucination.
      10 npm
      -