LinkingMem — Graph-native RAG Engine
khapu2906 · Coding · Leaning
LinkingMem is a graph-native RAG engine that runs as a self-hosted Docker service and links vector search with graph traversal so an LLM can answer questions from your own documents. Instead of matching text chunks by similarity alone, it walks the edges between entities to pull related facts into one grounded answer. That's the whole idea. If you want a RAG pipeline you control end to end, on your own hardware, this is built for that.
About LinkingMem — Graph-native RAG Engine
What Is LinkingMem
LinkingMem is a retrieval engine for building question-answering systems on private data. It pairs a Rust compute core with Python plugins, and it treats the knowledge graph as a first-class part of retrieval rather than an afterthought. A query enters the pipeline, gets embedded, hits an HNSW vector index, and then expands through graph edges before the LLM writes the final answer. That order matters. The graph step is what lets it connect facts that don't share vocabulary.
The engine ships as a Docker image, so you run it yourself. Text and image handling live in separate plugins you can start or skip, and the LLM client speaks the OpenAI-compatible protocol. Pick your backend. OpenAI, Ollama, Groq and Gemini-compatible endpoints all work, which is useful when you want to keep inference local.
The main catch is the setup cost. LinkingMem expects Rust 1.80+ and Python 3.11+, and you're responsible for wiring the config, the LLM key and the data files. It's a developer tool, not an app you install and forget.
Getting Started
- Pull the Docker image from Docker Hub (khapu2906/linkingmem) or clone the repository and install Rust 1.80+ and Python 3.11+ with uv.
- Copy
.env.exampleto.env, then set at leastOPENAI_API_KEY; pointOPENAI_BASE_URLat Ollama or another compatible provider if you'd rather run locally. - Review
plugins.tomlto decide which plugins to launch (the text plugin on port 8001, the image plugin on port 8002) and how the query pipeline is ordered. - Ingest your documents with the
POST /ingest/textorPOST /ingest/jsonendpoints to build the nodes, edges and vectors. - Send a question to
POST /queryand read the grounded LLM answer, or usePOST /query/multihopwhen you need the engine to follow several hops.
Product Information
A quick look at LinkingMem — Graph-native RAG Engine's pricing, supported platforms, and performance.
Best for
The users, tasks, and scenarios where this tool fits best.
Users
- Backend and AI engineers
- Teams with private documents
- Developers testing graph RAG ideas
Tasks
- Building a question-answering service over internal docs
- Multi-hop questions
- Mixing image and text retrieval
Scenarios
- Running a private knowledge base on your own server
- Prototyping a retrieval backend before committing to a managed service
- Adding grounding to an LLM you already host
Key features
Hybrid vector and graph retrieval
LinkingMem runs a two-stage retrieval pipeline. A query is embedded and matched against an HNSW vector index for fast nearest-neighbor search, then results expand through graph edges using breadth-first traversal. The vector step finds the entry points. The graph step gathers the surrounding context. For questions that hinge on relationships between entities, that second stage is often what makes the answer correct.
Multi-hop reasoning endpoint
The engine exposes a dedicated /query/multihop endpoint that follows several hops across the knowledge graph before generating an answer. This is aimed at questions no single document answers, where the model has to combine facts from different nodes. You get a chain of linked evidence rather than a single matching chunk.
Modular text and image plugins
Text embedding, entity extraction and answer generation live in a Python text plugin on port 8001, while image storage and embedding run in a separate plugin on port 8002. You can start only what you need. The image plugin offers two backends: a vision-LLM caption mode that shares the text vector space, or a CLIP encoder for true visual similarity without an LLM call.
OpenAI-compatible LLM client
The LLM client speaks the OpenAI-compatible API, so you can plug in OpenAI, Ollama, Groq, Gemini-compatible endpoints and similar services. Swapping providers is a config change, not a code change. Need local inference? The Ollama path handles that.
Rust core with a crash-safe delta store
The compute layer is written in Rust and serves an HTTP API on port 8000. It includes an LSM-style delta store with a write-ahead log and file locking, so ingested changes survive a restart. A concurrent embedding cache (moka) and a result cache cut repeated work on common queries.
Built-in observability and auth
The admin endpoints expose /health, /metrics, /graph/stats and node listings, and metrics come in a Prometheus-compatible format. API key auth and a token-bucket rate limiter sit in the middleware. That's one less layer to build. You can put the engine in front of more than one client right away.
Pros and cons
Pros
- Self-hosted by default, so private documents stay on your own infrastructure.
- Graph expansion handles multi-hop questions that plain vector search tends to miss.
- OpenAI-compatible LLM client means you can run inference locally through Ollama.
- Modular plugins let you skip image support or text features you don't need.
- Open source, with the full Rust core and Python plugins available to read and change.
Cons
- Setup is developer-grade: you need Docker plus Rust 1.80+ and Python 3.11+ to build from source, which rules out non-technical users.
- No hosted plan or web dashboard, so you're responsible for hosting, scaling and uptime.
- Documentation is code-first, meaning you'll spend time reading the repo and config files before your first query works.
Frequently asked questions
It's a retrieval engine that answers questions from your own documents by combining vector search with graph traversal, then passing the retrieved context to an LLM. The graph step is what separates it from a basic chunk-matching RAG setup.
Related content
Explore related tools, skills, and articles for LinkingMem — Graph-native RAG Engine.
LinkingMem — Graph-native RAG Engine Alternatives
Forefront
Forefront · CodingForefront is a web platform for building with open-source AI. It lets you fine-tune leading open-source language models on your own data, evaluate how they perform, and run them through an API or export them to host yourself. Developers who want the convenience of a closed-source platform but insist on owning their models and data are the target audience here.
Startkit
StartKit.AI · CodingStartkit is a boilerplate for building AI SaaS and AI wrapper products. Think of it as an AI startup boilerplate with the boring parts already wired up: authentication, Stripe and Lemon Squeezy payments, usage limits, transactional email, and an AI API starter that talks to OpenAI, Anthropic, Groq, or Llama. You clone the repo, set your price, and start on the part of your product that people actually pay for. It's Next.js under React and Tailwind, so most of the boilerplate code already feels familiar.
Testim
Tricentis · CodingTestim is an AI-powered test automation platform for building and running end-to-end tests across web, mobile, and Salesforce applications. It leans on machine learning to keep tests stable when an interface changes, so teams spend less time fixing broken selectors. Not bad for an automated testing tool you can start using today. You create tests by recording actions in a browser, then optionally add JavaScript when you need more control. It's a solid pick for busy QA teams.