# RAWThink [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/ygtalp/rawthink-mcp  
**GitHub Stars:** 0  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/rawthink

## Description
Persistent memory for AI thinking partnerships: hybrid search and a temporal knowledge graph.

## Tools
Capabilities this server exposes over MCP:

- **search_thoughts** — Hybrid search. `mode="overview"` gives one line per session
- **get_session** — Full content of a session by ID
- **store_thought** — Save a quick note as a qnote
- **reindex** — Re-index the vault into Qdrant
- **search_nodes** — Bounded. Filters by `domain` and `entity_type`; reports `total_matched` and `truncated
- **open_nodes** — Specific entities with their relations
- **read_graph** — Whole graph, paginated, with a summary mode
- **record** — Entities, relations and observations in one validated, atomic call
- **record_decision** — A decision with its rejected alternatives
- **revise** — Mark observations superseded, link what replaced them
- **invalidate_observations** — Belief revision without the relation link

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "rawthink": {
    "command": "uvx",
    "args": ["rawthink-mcp"]
  }
}
```

## Documentation

## What RAWThink MCP server does

RAWThink MCP server stores AI reasoning outside the current context window in a local vault. It covers two related forms of memory: searchable session and note content, plus a structured knowledge graph. The search layer can retrieve passages from past sessions and quick notes, while the graph records entities, relationships, observations, decisions, and changes to those observations.

The graph separates an entity's role from its subject domain. Supported roles include decisions, concepts, findings, rules, questions, artifacts, insights, tasks, events, and things. Domains include areas such as software, history, philosophy, health, writing, finance, and personal knowledge.

Decisions can include both the selected option and rejected alternatives. Observations can carry an epistemic status and can later be invalidated or superseded instead of silently deleted. This makes the archive useful for recovering not only conclusions, but also how those conclusions changed.

## How it works

RAWThink MCP server uses hybrid retrieval: dense BGE-M3 embeddings are combined with BM25 sparse search, with reciprocal rank fusion used to combine results. Qdrant stores the vector index. Ollama supplies the `bge-m3` model locally. Qdrant can run through Docker, or embedded mode can be selected with `QDRANT_PATH`.

The graph is stored in files owned by the user. Graph writes validate relation types and use an atomic record operation for entities, relations, and observations. Canonical relation types include `supports`, `contradicts`, `depends_on`, `supersedes`, `related_to`, and `informs`.

A session can be closed with `/rtclose`. The close process exports the conversation, extracts information for the graph, and creates a handoff for the next session. Accessed knowledge remains active while unused knowledge decays over roughly a 23-day half-life; older material remains available rather than being removed.

## Setup and configuration

Install Python 3.10 or newer, Docker for Qdrant unless using embedded mode, and Ollama with the `bge-m3` model. Install the package with `pip install rawthink-mcp`, then run `rawthink-install` to create the default `~/rawthink-vault` structure. A different vault location can be supplied with `rawthink-install --vault ~/my-vault`.

Start Qdrant with the generated Docker Compose configuration, then register the command with Claude Code:

```bash
claude mcp add --scope user rawthink -- rawthink-mcp
```

Run `rawthink-doctor` to check the vault, graph schema, BM25 state, Qdrant, index coverage, vector dimensions, Ollama, and MCP registration.

Tool exposure can be reduced with `RAWTHINK_TOOL_PROFILE`. The `recall` profile is read-only, `record` exposes the write path, and `full` exposes the complete set. The default is `full`.

## Tools and capabilities

RAWThink MCP server exposes tools for:

- Searching sessions and notes, viewing a complete session, saving qnotes, and rebuilding the Qdrant index.
- Finding graph nodes with domain and entity-type filters, opening selected entities with their relations, and reading the graph in pages or summary mode.
- Atomically recording entities, relations, and observations.
- Recording decisions with reasons and rejected alternatives.
- Revising observations by marking them superseded and linking their replacements.
- Invalidating observations when a belief should no longer be treated as valid without adding a replacement relation.

`search_thoughts` also supports an overview mode that returns one line per session. Bounded node searches report the total number of matches and whether results were truncated.

## Limitations and notes

RAWThink MCP server is local and does not provide a cloud-hosted memory service. Its setup depends on Python, Ollama, and either Docker-based Qdrant or embedded Qdrant storage. An incomplete indexing run can leave a usable-looking collection with only part of the vault indexed, so the doctor command's coverage check is important.

Upgrades may require migration. The documented migration path includes a dry-run graph migration, an optional apply step with a timestamped backup, and a full reindex when sparse-index term IDs change. A normal incremental reindex is not sufficient for that specific upgrade.

_Full upstream README: https://allmcps.com/mcp/rawthink/readme_