Local Markdown notes your AI can read, write and search through MCP

AI chats usually forget everything when a session ends. Basic Memory fixes this by keeping notes as Markdown files in a folder (by default ~/basic-memory). Your AI client reads and writes those files through an MCP server, so the next conversation can pick up where the last one stopped.

Notes use observations and wikilinks, which build a knowledge graph over time. Search covers both keywords and meaning, using embeddings on SQLite or Postgres. Because the files are plain text, you can also open and edit them yourself. The README says Obsidian works on the same folder with no setup.

The core is free and local under AGPL-3.0. There is also a paid hosted cloud version with cross-device sync, mobile access and backups, plus a Teams option for shared workspaces. The README says the cloud is optional and you can export to plain Markdown at any time.

Read more on interesting repos · GitHub

Memory server that lets AI agents store, search and learn from past interactions

Agents forget. Each new chat starts blank unless you add a way to save and look up past information. Hindsight is a server that does this job. Your agent sends it information to keep, and later asks it questions.

You work with it through three operations: retain (store something), recall (search stored memories) and reflect (generate an answer shaped by what it knows). Memories live in named banks, such as one per user or per code repo. It runs on an LLM you choose, and the Docker setup keeps data in an embedded Postgres.

The README says it aims at agents that learn, not just recall conversation history, and sets itself against plain RAG and knowledge graphs. It cites top results on the LongMemEval benchmark and notes that other vendors' scores are self-reported. Treat those claims as the authors' own and check the live benchmark page.

Read more on interesting repos · GitHub

WeKnora is a knowledge platform from Tencent, written in Go. You upload documents (PDF, Word, Excel, images and more) or sync them from tools like Feishu, Confluence, Notion and GitLab. They become knowledge bases that three features share: RAG question answering with citations, an agent for multi-step tasks, and a wiki that organizes the content.

The agent can search the knowledge bases, call external MCP tools, run installed skills in Docker, E2B or Cube sandboxes, and operate your own Chrome or Edge through a browser extension. It also keeps long-term memory across sessions, which the user confirms.

Compared with a plain RAG chatbot, it adds workspaces with role-based access, audit logs, chat channels such as WeCom, Slack and Telegram, and a built-in MCP server so tools like Cursor or Claude can query your knowledge bases. Models, vector databases and storage are swappable, including local Ollama models.

Read more on interesting repos · GitHub

Every new AI coding session starts by asking what is true about the project right now. Code is in the repository, decisions are in old chats, and test results are in tools. Rta-Smriti pulls these into one local database so an agent can pick up where the last one stopped.

It indexes the Git checkout into project-scoped SQLite, recording file hashes, symbols, imports, evidence and memories. It keeps kinds of fact apart: a test result or a human instruction counts as accepted truth, while an inference or brainstorm needs review before promotion. When a task starts, a context compiler picks direct evidence first, respects a token budget, and writes a receipt of what it included.

It is an evidence and continuity layer, not an agent. It does not run project work or choose models. It offers a CLI, a local MCP server and a loopback web console. Encrypted sharing of selected memory between devices is optional and off by default. The README calls the current release an advanced early-adopter alpha.

Read more on interesting repos · GitHub

Coding agents often work from stale or guessed knowledge of your codebase, and they forget what went wrong last session. Cortex Suite splits that problem in two. quartz-ctx answers what the code is: types, signatures, enum variants and file:line locations. cortex remembers what you learned: patterns, anti-patterns, decisions and corrections, kept in SQLite.

Both servers check freshness when they answer, using file metadata, then a content hash, then a re-parse. An edit shows up on the very next call, with no reindex or restart. cortex does not parse code itself. It ingests quartz-ctx's output, so the two cannot disagree about what a type is. Rust is parsed with syn. Python, TypeScript, JavaScript, Go, Java, C#, C/C++, Ruby and PHP use tree-sitter.

Two things set it apart. It traces calls across languages, such as a JavaScript fetch to a Python route, and reports the unmatched halves. In Claude Code and VS Code Copilot it also installs hooks that push a recorded trap to the agent when an edit or a failing build matches it. Everything runs locally, with no network calls, API keys or telemetry.

Read more on interesting repos · GitHub

Most agent memory is a black box. Text goes in, embeddings come out, and nobody can see what was stored. OpenViking organizes context as a virtual filesystem under viking:// instead. Agents use familiar commands such as ls, tree, read, write and grep, and you can open any directory to check or edit what the agent knows.

Content falls into three types: resources (documents and code), memories (user preferences and experience), and skills (how to do tasks). Directories carry generated summaries at three levels: a one-sentence abstract (L0), an overview (L1), and the full original (L2). An agent reads the short summaries first and opens full files only when needed. Search can be limited to one subtree rather than a flat pool of vectors.

When a session is committed, the conversation is archived and memories are extracted as Markdown files you can read, edit and merge. The README reports gains on the LoCoMo and tau2-bench benchmarks with lower token use. These are the authors' own results, run with Doubao models, so check them against your own setup.

Read more on interesting repos · GitHub

Most AI agents recall things by embedding similarity. That gives a score, but no structure, no relationships and no explanation of why a result came back. Semantica adds a graph layer underneath your LLM, vector store and agent framework to fill that gap.

It takes data from files, databases, the web, streams and platforms like Databricks, Snowflake and SAP. It extracts entities and relations, flags conflicting facts, merges duplicates and builds a graph. Ontologies (OWL, SHACL, SKOS) define what entities mean. Reasoning engines such as forward chaining, Rete, Datalog and SPARQL run over the graph.

The README compares it with a plain vector database plus RAG, and with LLM memory. It says those silently overwrite conflicting facts and keep no decision history. Semantica keeps decisions as queryable objects with provenance. Graph building, reasoning and provenance need no LLM. It explains the context and decisions around a model, not what happens inside the model.

Read more on interesting repos · GitHub

Most chatbots forget people between sessions, or replay old text chunks that may not matter. Honcho adds a memory layer. You save messages and events, and Honcho works through them in the background to draw conclusions about each participant.

The data model is simple. A workspace holds peers (users, agents, groups, projects or ideas). Peers take part in sessions, and messages live on sessions. Honcho keeps a representation for each peer. You can ask it questions in plain language, run hybrid search (keyword plus vector), or request prompt-ready context formatted for OpenAI or Anthropic.

It is a FastAPI server. You can use the managed service, run it locally with its CLI, or self-host it. It also ships memory plugins for coding agents such as Claude Code, Codex, Cursor and OpenCode. The README claims strong benchmark results, which you should check on its evals page. Note the AGPL-3.0 license if you self-host.

Read more on interesting repos · GitHub

Agents tend to start every session from scratch. You re-explain the project, they re-read the same documents, and a workflow that worked once gets rediscovered. This project is a memory hub that keeps that experience and hands it to the next agent.

It saves four kinds of assets. Chat Memory distils conversations in layers, from raw dialogue up to a persona. Skills are reusable procedures extracted from finished work. A Wiki turns documents into linked pages. A CodeGraph indexes symbols, call relationships and the impact of a change. A web panel lets people set who owns each asset, who can see it (private, team, restricted or agent) and which agent gets it.

The README contrasts it with plain chat history and standard RAG. Those find text. This also tracks versions, ownership and sharing, and lets you equip different agents with different assets. Agents connect by pointing their base URL at a proxy, so no plugin, hook or MCP server is needed. The README text provided was cut off, so details beyond this are not covered here.

Read more on interesting repos · GitHub

When you ask an AI assistant about a large project, it often reads many files or greps blindly. Graphify builds a map first. You type /graphify in your assistant, and it writes a graph of the concepts in your code, docs, PDFs, images and video.

Code is parsed with tree-sitter into an abstract syntax tree. That step is deterministic, uses no LLM and keeps everything on your machine. Docs, PDFs, images and video get a semantic pass from your assistant's model or an API key you configure. The graph is split into communities with the Leiden algorithm.

Unlike RAG tools built on embeddings, it uses no vector store. It is a real graph you walk. Every edge is tagged EXTRACTED (stated in the source) or INFERRED (resolved by graphify), so you can see what was read and what was derived. The README reports benchmarks against mem0 and supermemory on LOCOMO. Those are the authors' own numbers.

Read more on interesting repos · GitHub

Screenpipe runs in the background and keeps a searchable record of what you saw, typed and heard on your computer. You can ask things like "what did I see in the last 5 mins?", or let an agent use that history as context. The README also pitches it to companies that want to find repetitive work worth automating.

It does not record every frame. It captures when something changes, such as an app switch, click, typing pause or scroll. Each capture pairs a screenshot with the text the operating system already exposes (the accessibility tree), and falls back to OCR when that isn't available. Audio is transcribed with Whisper locally, or with Deepgram in the cloud.

The README compares it to Rewind.ai (now Limitless), Microsoft Recall, Granola and Otter.ai. It is source-available, not open source: personal non-commercial use is allowed, and commercial use needs a license. Capture history stays on your device by default, but cloud AI, sync and team features use separate data paths.

Read more on interesting repos · GitHub

Most RAG systems parse a page into text chunks. That step often drops tables, charts and layout, so the model never sees the answer. PixelRAG skips parsing: it renders each document as screenshot tiles and searches the images themselves.

It has two main parts. The pixelshot command uses headless Chromium (or poppler for PDFs) to turn pages into tiles. An embedding model, Qwen3-VL-Embedding-2B with LoRA fine-tuning on screenshot data, places the tiles in a vector space. The tiles go into a FAISS or Qdrant index, and a FastAPI server answers queries. A query can be text or an image.

A hosted index of 8.28M Wikipedia pages is available with no API key, and you can build an index from your own files. The renderer also ships as a Claude Code plugin and an opencode plugin, so an agent can look at a page instead of fetching raw HTML. This is the official code for a Berkeley research paper.

Read more on interesting repos · GitHub

QMD is a search engine for the files you want to remember: markdown notes, meeting transcripts, documentation and knowledge bases. You point it at folders, which it calls collections, and it builds an index on your machine. The language models run locally through node-llama-cpp using GGUF model files.

A full query works in stages. The query is expanded into a few variants. Keyword matches (BM25) and meaning-based matches (vector search) are found separately. The two result lists are merged with reciprocal rank fusion, and a language model re-ranks the merged list. You can also run only the keyword search or only the vector search when you want speed.

It is built with agents in mind. Output can be JSON or a plain file list, and it runs as an MCP server over stdio or HTTP. You can attach short descriptions to collections and paths. These come back with matching results, so a model can judge which documents to open. It can also be used as a Node or Bun library.

Read more on interesting repos · GitHub

Language models can't read the live web on their own, and raw HTML is messy and costly in tokens. Firecrawl fetches pages for you and returns markdown, JSON or screenshots. It handles JavaScript-heavy pages, proxies and rate limits behind the API.

You call it over HTTP, or through Python, Node.js and CLI clients. Search returns full page content for each result. Scrape converts one URL. Crawl and Map cover a whole site. Batch Scrape handles many URLs at once. Interact lets you scrape a page and then drive it with prompts. Agent takes a plain-language request and finds the data itself, with no URLs needed.

It is open source under AGPL-3.0 and also sold as a hosted service. The README's quick start uses an API key from firecrawl.dev, so it assumes the hosted version. It also ships a skill for coding agents and an MCP server. The README names Apify and ScrapingBee in an example but gives no real comparison.

Read more on interesting repos · GitHub

Open Notebook is a notebook app for research. You collect sources such as PDFs, videos, audio files, web pages and Office documents into a notebook. Then you ask questions about them, write notes, and turn them into summaries or podcasts.

It runs on your own machine with Docker. A web UI on port 8502 and a REST API on port 5055 sit on top of a SurrealDB database. Your data stays in local folders, and AI calls go to whichever provider you set up. Search works two ways: full-text and vector.

The README compares it with Google's Notebook LM. Open Notebook supports 18+ providers (OpenAI, Anthropic, Ollama, LM Studio and others) instead of Google models only. Podcasts can have 1 to 4 speakers instead of 2. The README admits its citations are basic for now and still need work.

Read more on interesting repos · GitHub

AI assistants forget everything between conversations. Supermemory sits beside them and keeps a memory. It pulls facts out of what users say, tracks changes and contradictions, and drops information that has expired.

You can use it in three ways. Plugins and an MCP server add memory to tools like Claude Code, Cursor and Codex. A TypeScript and Python SDK lets developers add memory to their own apps. A local server runs the same API on your machine.

It handles the vector database, embedding and chunking steps for you. It combines document search (RAG) and personal memory in one query, and keeps a profile of stable facts and recent activity for each user. The README says it ranks first on three memory benchmarks. That is the team's own claim, so check the research page yourself.

Read more on interesting repos · GitHub

PDFs store text as positioned fragments, not paragraphs, so a naive extract scrambles columns and tables. LiteParse rebuilds the page layout and gives you text, Markdown or JSON, with the position of each piece of text.

It is written in Rust and reads PDFs with the PDFium library, at about 2-5 ms per page according to the README. When a page needs it, it runs OCR. Tesseract is bundled, or you can plug in any OCR server (EasyOCR, PaddleOCR or your own) through a simple HTTP API. Word, Excel, PowerPoint and image files are converted first, then go through the same steps.

It uses no ML model, GPU or cloud service. The README compares it with markitdown, opendataloader and pdf-inspector and reports higher scores on three public benchmarks; these are the authors' own runs. The authors say it is weaker on dense tables, charts, handwriting and scans, and point to their paid cloud product, LlamaParse, for those.

Read more on interesting repos · GitHub

Coding agents forget everything when a session ends, so you explain the same architecture and re-find the same bugs each time. agentmemory runs a local server that stores what happened and returns relevant pieces when the agent asks.

Agents connect in one of three ways: hooks that capture activity automatically, an MCP server with tools such as memory_recall and memory_smart_search, or a plain REST API. Because all agents talk to one server, something learned in Claude Code can be recalled from Cursor or Codex. It is built on the iii engine and needs no external database.

It works without any API key, using BM25 keyword search. You can turn on local embeddings for meaning-based search, or add an LLM provider for compressing observations. The README says it builds on Karpathy's LLM Wiki pattern with confidence scoring, lifecycle, knowledge graphs and hybrid search. Its benchmark and competitor claims come from the authors, so test it on your own workflow.

Read more on interesting repos · GitHub

Agents forget things between chats, and most note-search tools only hand back a list of pages to read yourself. GBrain stores explicit facts with their sources, lets you correct or withdraw them, and makes the same memory available to several agents.

You can start with keyless memory and keyword retrieval. Later you can add semantic search, a synthesis layer that writes a cited answer and says what the brain doesn't know yet, and a typed knowledge graph for questions like who works at a company. Agents connect over MCP or through guided installs, and the brain can run on your own machine, reachable over Tailscale.

The author, Garry Tan, runs it as the memory behind his own OpenClaw and Hermes agents, with background jobs that ingest and enrich data overnight. That always-on mode costs the most, since it needs a server and API usage. The README notes that its benchmark numbers compare whole systems and are not a general guarantee.

Read more on interesting repos · GitHub

LLMs and text-analysis tools work best with clean text, but real documents come as PDFs, slide decks, spreadsheets and scans. MarkItDown reads many of these formats and writes Markdown, which stays close to plain text while keeping structure like headings, lists, tables and links.

You can use it as a command-line tool or as a Python library. Each file type has its own converter, and extra dependencies are installed per format, so you only pull in what you need. If you pass in an OpenAI-compatible client, an LLM can describe images and read text from images embedded in documents. Third-party plugins can add more formats.

The README compares it to textract, but says it focuses on preserving document structure. The output is meant for machines to read, so it may not suit cases where a person needs a faithful copy of the original layout. For harder documents it can call paid Azure services (Document Intelligence or Content Understanding) instead of its offline converters.

Read more on interesting repos · GitHub

Coding agents forget everything when a session ends. You then have to explain the project, past decisions and old bugs all over again. Claude-mem keeps a running memory of what the agent did, so the next session starts with that background.

It works through lifecycle hooks in Claude Code: session start, prompt submit, tool use, stop and session end. The hooks capture observations about what the agent did. A local worker service, run with Bun, turns them into summaries and stores them in SQLite. A Chroma vector database adds semantic search alongside keyword search. When a new session starts, relevant context is injected back in.

Search is layered to keep token use down. The agent first gets a compact index of results, then a timeline around the interesting ones, and only then full details for the IDs it picked. The README claims about 10x token savings from this. It also lists installers for OpenCode, OpenClaw, Antigravity and others. For the memory provider, you can use the hosted claude-mem observer, your own OpenRouter or Gemini key, or your Anthropic plan.

Read more on interesting repos · GitHub