Memoria Básica te permite construir conocimiento persistente mediante conversaciones naturales con Grandes Modelos de Lenguaje (LLM) como Claude, a la vez que guardas todo en archivos Markdown simples en tu ordenador. Utiliza el Protocolo de Contexto de Modelo (MCP) para que cualquier LLM compatible pueda leer y escribir en tu base de conocimiento local.
Sitio web: https://basicmachines.co
Documentación: https://memory.basicmachines.co
Los asistentes de IA pueden cargar contexto de archivos locales en una nueva conversación
Las notas se guardan localmente como archivos Markdown en tiempo real
No se requieren conocimientos del proyecto ni indicaciones especiales
https://github.com/user-attachments/assets/a55d8238-8dd0-454a-be4c-8860dbbd0ddc
Related MCP server: memora
# Install with uv (recommended)
uv tool install basic-memory
# Configure Claude Desktop (edit ~/Library/Application Support/Claude/claude_desktop_config.json)
# Add this to your config:
{
"mcpServers": {
"basic-memory": {
"command": "uvx",
"args": [
"basic-memory",
"mcp"
]
}
}
}
# Now in Claude Desktop, you can:
# - Write notes with "Create a note about coffee brewing methods"
# - Read notes with "What do I know about pour over coffee?"
# - Search with "Find information about Ethiopian beans"
Puede ver el contexto compartido a través de archivos en ~/basic-memory (ubicación del directorio predeterminado).
Puede utilizar Smithery para configurar automáticamente la memoria básica para Claude Desktop:
npx -y @smithery/cli install @basicmachines-co/basic-memory --client claudeEsto instala y configura Basic Memory sin necesidad de modificar manualmente el archivo de configuración de Claude Desktop. El servidor Smithery aloja el componente del servidor MCP, mientras que sus datos se almacenan localmente como archivos Markdown.
La mayoría de las interacciones de LLM son efímeras: se hace una pregunta, se recibe una respuesta y todo se olvida. Cada conversación comienza desde cero, sin el contexto ni el conocimiento de las anteriores. Las soluciones alternativas actuales tienen limitaciones:
Los historiales de chat capturan conversaciones, pero no son conocimiento estructurado
Los sistemas RAG pueden consultar documentos, pero no permiten que los LLM los escriban.
Las bases de datos vectoriales requieren configuraciones complejas y a menudo residen en la nube
Los gráficos de conocimiento generalmente necesitan herramientas especializadas para mantenerse
La memoria básica aborda estos problemas con un enfoque sencillo: archivos Markdown estructurados que tanto usuarios como LLM pueden leer y escribir. Ventajas clave:
Local-first: Todo el conocimiento permanece en los archivos que usted controla
Bidireccional: tanto usted como el LLM leen y escriben en los mismos archivos
Estructurado pero simple: utiliza Markdown familiar con patrones semánticos
Gráfico de conocimiento transitable: los LLM pueden seguir vínculos entre temas
Formatos estándar: funciona con editores existentes como Obsidian
Infraestructura ligera: solo archivos locales indexados en una base de datos SQLite local
Con Memoria Básica, puedes:
Tener conversaciones que se basen en conocimientos previos
Crea notas estructuradas durante conversaciones naturales
Tenga conversaciones con LLM que recuerden lo que han discutido antes
Navegue por su gráfico de conocimiento semánticamente
Mantén todo local y bajo tu control
Utilice herramientas conocidas como Obsidian para ver y editar notas
Construya una base de conocimientos personal que crezca con el tiempo
Supongamos que estás explorando métodos de preparación de café y quieres poner en práctica tus conocimientos. Así es como funciona:
Comience chateando normalmente:
I've been experimenting with different coffee brewing methods. Key things I've learned:
- Pour over gives more clarity in flavor than French press
- Water temperature is critical - around 205°F seems best
- Freshly ground beans make a huge difference...continuar la conversación.
Pídale al LLM que le ayude a estructurar este conocimiento:
"Let's write a note about coffee brewing methods."LLM crea un nuevo archivo Markdown en su sistema (que puede ver instantáneamente en Obsidian o en su editor):
---
title: Coffee Brewing Methods
permalink: coffee-brewing-methods
tags:
- coffee
- brewing
---
# Coffee Brewing Methods
## Observations
- [method] Pour over provides more clarity and highlights subtle flavors
- [technique] Water temperature at 205°F (96°C) extracts optimal compounds
- [principle] Freshly ground beans preserve aromatics and flavor
## Relations
- relates_to [[Coffee Bean Origins]]
- requires [[Proper Grinding Technique]]
- affects [[Flavor Extraction]]La nota incorpora contenido semántico y enlaces a otros temas a través del formato Markdown simple.
Verá este archivo en su computadora en tiempo real en el directorio del proyecto actual (predeterminado ~/$HOME/basic-memory ).
La sincronización en tiempo real está habilitada de forma predeterminada con la versión v0.12.0
En un chat con el LLM, puedes hacer referencia a un tema:
Look at `coffee-brewing-methods` for context about pour over coffeeEl Máster en Derecho (LLM) ahora puede generar contexto enriquecido a partir del grafo de conocimiento. Por ejemplo:
Following relation 'relates_to [[Coffee Bean Origins]]':
- Found information about Ethiopian Yirgacheffe
- Notes on Colombian beans' nutty profile
- Altitude effects on bean characteristics
Following relation 'requires [[Proper Grinding Technique]]':
- Burr vs. blade grinder comparisons
- Grind size recommendations for different methods
- Impact of consistent particle size on extractionCada documento relacionado puede generar más contexto y generar una rica comprensión semántica de su base de conocimientos.
Esto crea un flujo bidireccional donde:
Los humanos escriben y editan archivos Markdown
Los LLM leen y escriben a través del protocolo MCP
La sincronización mantiene todo consistente
Todo el conocimiento permanece en archivos locales.
Bajo el capó, Memoria básica:
Almacena todo en archivos Markdown
Utiliza una base de datos SQLite para buscar e indexar
Extrae el significado semántico de patrones Markdown simples
Los archivos se convierten en objetos Entity
Cada Entity puede tener Observations , o hechos asociados a ella.
Relations conectan entidades entre sí para formar el gráfico de conocimiento.
Mantiene el gráfico de conocimiento local derivado de los archivos
Proporciona sincronización bidireccional entre archivos y el gráfico de conocimiento.
Implementa el Protocolo de Contexto de Modelo (MCP) para la integración de IA
Expone herramientas que permiten a los asistentes de IA recorrer y manipular el gráfico de conocimiento.
Utiliza URL de memoria:// para hacer referencia a entidades en herramientas y conversaciones
El formato del archivo es simplemente Markdown con algún marcado simple:
Cada archivo Markdown tiene:
title: <Entity title>
type: <The type of Entity> (e.g. note)
permalink: <a uri slug>
- <optional metadata> (such as tags) Las observaciones son datos sobre un tema. Se pueden agregar creando una lista de Markdown con un formato especial que puede hacer referencia a una category , tags con el carácter "#" y un context opcional.
Formato de Markdown de observación:
- [category] content #tag (optional context)Ejemplos de observaciones:
- [method] Pour over extracts more floral notes than French press
- [tip] Grind size should be medium-fine for pour over #brewing
- [preference] Ethiopian beans have bright, fruity flavors (especially from Yirgacheffe)
- [fact] Lighter roasts generally contain more caffeine than dark roasts
- [experiment] Tried 1:15 coffee-to-water ratio with good results
- [resource] James Hoffman's V60 technique on YouTube is excellent
- [question] Does water temperature affect extraction of different compounds differently?
- [note] My favorite local shop uses a 30-second bloom timeLas relaciones son enlaces a otros temas. Definen cómo se conectan las entidades en el grafo de conocimiento.
Formato Markdown:
- relation_type [[WikiLink]] (optional context)Ejemplos de relaciones:
- pairs_well_with [[Chocolate Desserts]]
- grown_in [[Ethiopia]]
- contrasts_with [[Tea Brewing Methods]]
- requires [[Burr Grinder]]
- improves_with [[Fresh Beans]]
- relates_to [[Morning Routine]]
- inspired_by [[Japanese Coffee Culture]]
- documented_in [[Coffee Journal]]Para la instalación con un solo clic, haga clic en uno de los botones de instalación a continuación...
Puedes usar Basic Memory con VS Code para recuperar y almacenar información fácilmente mientras programabas. Haz clic en los botones de instalación de arriba para una configuración con un solo clic o sigue las instrucciones de instalación manual a continuación.
Agrega el siguiente bloque JSON a tu archivo de configuración de usuario (JSON) en VS Code. Para ello, presiona Ctrl + Shift + P y escribe Preferences: Open User Settings (JSON) .
{
"mcp": {
"servers": {
"basic-memory": {
"command": "uvx",
"args": ["basic-memory", "mcp"]
}
}
}
}Opcionalmente, puede agregarlo a un archivo llamado .vscode/mcp.json en su espacio de trabajo. Esto le permitirá compartir la configuración con otros.
{
"servers": {
"basic-memory": {
"command": "uvx",
"args": ["basic-memory", "mcp"]
}
}
}La memoria básica se crea utilizando el MCP (Protocolo de contexto de modelo) y funciona con la aplicación de escritorio Claude ( https://claude.ai/ ):
Configurar Claude Desktop para utilizar memoria básica:
Edite su archivo de configuración MCP (generalmente ubicado en ~/Library/Application Support/Claude/claude_desktop_config.json para OS X):
{
"mcpServers": {
"basic-memory": {
"command": "uvx",
"args": [
"basic-memory",
"mcp"
]
}
}
}Si desea utilizar un proyecto específico (consulte Proyectos múltiples ), actualice la configuración de Claude Desktop:
{
"mcpServers": {
"basic-memory": {
"command": "uvx",
"args": [
"basic-memory",
"--project",
"your-project-name",
"mcp"
]
}
}
}Sincroniza tus conocimientos:
Basic Memory sincronizará los archivos de tu proyecto en tiempo real si realizas ediciones manuales.
En Claude Desktop, el LLM ahora puede utilizar estas herramientas:
write_note(title, content, folder, tags) - Create or update notes
read_note(identifier, page, page_size) - Read notes by title or permalink
build_context(url, depth, timeframe) - Navigate knowledge graph via memory:// URLs
search_notes(query, page, page_size) - Search across your knowledge base
recent_activity(type, depth, timeframe) - Find recently updated information
canvas(nodes, edges, title, folder) - Generate knowledge visualizationsEjemplos de indicaciones para probar:
"Create a note about our project architecture decisions"
"Find information about JWT authentication in my notes"
"Create a canvas visualization of my project components"
"Read my notes on the authentication system"
"What have I been working on in the past week?"Consulte la documentación para obtener más información, que incluye:
AGPL-3.0
Se agradecen las contribuciones. Consulta la Guía de Contribución para obtener información sobre cómo configurar el proyecto localmente y enviar solicitudes de colaboración.
Creado con ♥️ por Basic Machines
Follow the Basic Memory knowledge graph from a note: the note, its observations, and the notes its relations reach, up to depth hops (1-5). identifier is a path, permalink, memory:// URL, or a pattern such as 'specs/*'. since limits related results to recent changes. compact returns the graph without note bodies; read chosen notes with bm_read.
Inputs: project (required), identifier (required), page, depth, +5 more. Returns: result
Delete a Basic Memory note (identifier) or a directory (path). A directory delete removes every file under it and needs recursive=true. Pass expected_checksum (from bm_read) to delete a note only if it is still the revision you read. A note that does not exist is an error. This cannot be undone.
Inputs: project (required), path, recursive, identifier, +2 more. Returns: result
Change part of an existing Basic Memory note. command: append or prepend content; find_replace find_text with content (exact text, which must occur expected_replacements times, default 1); replace_section, insert_before_section or insert_after_section for a section heading ('Decisions', 'Auth/Decisions', 'Decisions[1]', as bm_read takes it); set_metadata to merge metadata into the frontmatter without touching the body. metadata also merges with any other command. Pass expected_checksum (from bm_read) to edit only the revision you read. A missing note is an error; create notes with bm_write.
Inputs: command (required), project (required), identifier (required), content, +7 more. Returns: result
Find files in a Basic Memory project, recursively. With name, match file names against a glob ('meeting'). With filters, match notes by frontmatter, e.g. {"status": "active"} or {"priority": {"$in": ["high"]}}, and with fields return just those frontmatter values per note. path limits the search to a folder. For ranked text or meaning search, use bm_search.
Inputs: project (required), name, page, path, +5 more. Returns: result
List one folder of a Basic Memory project: its subfolders, then its files with title, date and id. project is required; '/' lists its root. Discover projects with bm_project(command='list'). Filter files with glob and order them with sort. For a recursive search by name or frontmatter, use bm_find.
Inputs: project (required), glob, page, path, +3 more. Returns: result
Read the Basic Memory manual. With no arguments, the index of every page. page reads one page: 'bm-search(3)' for an MCP tool, 'grep(1)' for a shell command; a tool name such as 'bm_search' works too. query lists the pages that mention every word given, like man -k.
Inputs: page, query, output_format. Returns: result
Move or rename a Basic Memory note (identifier) or a directory (path) within its project. destination is the new project-relative path; ending it with '/' moves into that folder under the current name ('archive/'). A note keeps its file extension ('.markdown' may become '.md'). Pass expected_checksum (from bm_read) to move a note only if it is still the revision you read. Moving into another project is refused: bm_read, bm_write there, then bm_delete.
Inputs: project (required), destination (required), path, identifier, +2 more. Returns: result
Basic Memory projects. command: list (projects, grouped by workspace); create (name, path, optional set_default, workspace); recent (what changed lately in the required project: since, items, paging).
Inputs: command (required), name, page, path, +7 more. Returns: result
Read a Basic Memory note or file by path, permalink, memory:// URL or exact title. Slice a long note with section (a heading), start_line/end_line or max_tokens; line numbers count the whole file, frontmatter included. A text file such as .txt takes start_line/end_line too. include_content=false returns only the metadata and the checksum that bm_write and bm_edit take as expected_checksum. Images come back as images and other binary files as documents. A missing note is an error: find notes with bm_search.
Inputs: project (required), identifier (required), section, end_line, +5 more.
Basic Memory note schemas (Picoschema). command: validate notes against their schema (one note_type, one note by identifier, or every type that has a schema); infer a schema from the notes of a note_type; diff a note_type's notes against its schema to find drift. A schema is a note with type: schema whose entity field names the note type it describes.
Inputs: command (required), project (required), note_type, threshold, +2 more. Returns: result
Search a Basic Memory project, ranked by relevance. query supports quoted phrases, AND/OR/NOT and tag:name. mode picks hybrid (the default when semantic search is available), text, semantic, title or permalink (globs with *). Narrow with filters (frontmatter), note_types, items (notes, observations, relations) and since. lines returns the matching lines of each hit with that many lines of context, like grep. path limits the search to a folder; identifier searches one note. Scope every search with project (one project), projects (a list), or all_projects=true. Read full notes with bm_read.
Inputs: mode, page, path, items, +18 more. Returns: result
Create or replace a Basic Memory note. Give a file path as identifier ('notes/plan.md'), or title plus directory. With a path the file lands exactly there and the title comes from the content's frontmatter, then title, then the file name. An existing note is an error unless overwrite=true; pass expected_checksum (from bm_read) to replace only the revision you read. To change part of a note use bm_edit. Content may hold frontmatter, observations ('- [category] fact #tag') and relations ('- relation_type [[Other Note]]').
Inputs: content (required), project (required), tags, title, +7 more. Returns: result
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 12 tools
There is real overlap among three retrieval tools (bm_find, bm_list, bm_search), but the descriptions explicitly route the agent: bm_list for one folder, bm_find for recursive name/frontmatter matching, bm_search for ranked text/semantic search. Similarly bm_read (one note body) is distinguished from bm_context (graph traversal) and bm_write (full replace) from bm_edit (partial change). Only a small chance of misselection remains for an agent skimming names.
All 12 tools follow a single predictable bm_<word> snake_case pattern with no style mixing. Most suffixes are verbs (find, list, read, write, edit, move, delete, search), but a few are nouns/commands (bm_context, bm_schema, bm_project, bm_man), which is a minor deviation rather than an inconsistency.
Twelve tools sit comfortably in the well-scoped range and each maps to a distinct capability: directory listing, find, search, read, write, edit, move, delete, graph context, schema ops, project ops, and docs. None look like padding, and the surface is not so thin that agents would have to chain workarounds.
Note lifecycle is fully covered (create/replace, read, partial edit, move, delete, plus graph context and search), and bm_schema and bm_project cover schema and project management. Minor gaps: bm_project only supports list/create/recent (no rename or delete of projects), and there is no copy/duplicate operation, though the description notes the read+write+delete workaround.
Personal wiki and memory layer for AI assistants. Persistent, structured memory across sessions.
Persistent memory and knowledge graph for AI assistants — keyword + vector + graph search.
Long-term memory for your AI as a private knowledge graph: facts, people, links, sources.
Turn your notes, links and conversations into a Living Brain your AI tools share and build on.