# How to Give Your Coding Agent Persistent Project Memory: devmemory, Graphicle and MCP

> AI Release · @ai_release1 · https://ai-release.org/guides/kak-dat-ii-agentu-postoyannuyu-pamyat-o-proekte-devmemo_en.html

Every new chat session your coding agent starts from zero: it does not know your folder structure, which files call each other, or why you chose a certain database last week. This guide shows how to fix that by connecting a memory/code-graph server to your AI client over MCP (Model Context Protocol — an open standard that lets an AI client talk to external programs as "servers"). The concrete example here is Graphicle — a single Rust program (Rust is a compiled language; you build a binary and run it) that combines a code graph (a map of which files, functions and classes reference each other) with memory for coding agents. Tools in this space include devmemory and Graphicle; the same MCP steps apply to any MCP-compatible memory tool, and the setup below is what the source material documents for Graphicle.

## Requirements and preparation
![Illustration: Requirements and preparation](https://ai-release.org/guides/img/kak-dat-ii-agentu-postoyannuyu-pamyat-o-proekte-devmemo-en-1.jpg)


- An MCP-capable client. The project description names Claude Code, Codex and Cursor, and states it works with any MCP client. Without MCP support in your client, nothing below works.
- The Graphicle program from the GitHub repository `Graphicle-AI/graphicle`.
- Either a prebuilt binary from the repository or a Rust toolchain if you build from source.
- Read access to the project folder you want the agent to remember.
- A terminal (bash, PowerShell or the built-in terminal of your client).

Important honesty note: the project description does not publish installation details, license terms or system requirements. So treat the commands below as the standard flow and confirm the exact names against the repository README before you rely on them.

Use this checklist to know when you are actually ready:

- [ ] Your client has an MCP servers section in its settings or docs.
- [ ] You know the absolute path to your project folder, for example `/home/dev/projects/shop-api`.
- [ ] You have the Graphicle binary or have built it successfully.
- [ ] You know where your client stores its MCP config file.
- [ ] You can restart the client to reload the MCP server list.

## Step-by-step instruction
![Illustration: Step-by-step instruction](https://ai-release.org/guides/img/kak-dat-ii-agentu-postoyannuyu-pamyat-o-proekte-devmemo-en-2.jpg)


1. Confirm your client can host MCP servers. Open its settings or documentation and look for an "MCP" or "MCP servers" entry. Expected result: your client either has that section or its docs say it supports MCP. If there is nothing, stop here and switch to Claude Code, Codex, Cursor or another MCP client — this is the one hard condition stated by the project. Why it matters: MCP is the plug that carries your project memory into the model, and a client without the socket cannot use it.

2. Get the Graphicle program. Clone the repository and, if no ready binary is available, build it.
```
git clone https://github.com/Graphicle-AI/graphicle
cd graphicle
cargo build --release
```
**Example:** a successful build ends with a line like `Finished release [optimized] target(s)` and puts the executable under `target/release/`. Expected result: you have a real file path you can point your client at. Why it works: Rust compiles the whole program into one binary, so the client only needs to launch that one file.

3. Find your client's MCP config file. It is usually a JSON file in the client's config directory and contains a list of servers. Expected result: you can see where other tools are registered. **Example:** the section is normally an object listing each server by name with a command and arguments. The exact file location and key names differ per client, so copy the key names from your client's own MCP documentation rather than guessing.

4. Register Graphicle as a server. Add an entry that launches the Graphicle binary and passes it your project folder. The shape is usually close to this:
```json
{
  "mcpServers": {
    "graphicle": {
      "command": "/home/dev/graphicle/target/release/graphicle",
      "args": ["/home/dev/projects/shop-api"]
    }
  }
}
```
Expected result: the file saves without syntax errors (a missing comma or quote here is the most common breakage). Why it works: the client starts the program as a background process and speaks MCP to it, so Graphicle can read your code and answer the agent's questions about it.

5. Restart the client or reload MCP servers, then check the connection. Expected result: your client lists `graphicle` as connected or running. **Example:** the server list shows the name you chose (`graphicle`) with a green or "connected" state instead of "failed".

6. Let it build the code graph. On first run the program needs to walk your project and record the relationships between files and symbols. Expected result: an index or graph is created for `/home/dev/projects/shop-api`, and later runs reuse it. Why it works: the graph is what turns "where is authentication handled?" into a real answer with file paths instead of a guess.

7. Test the memory with two questions in two separate sessions. Ask your agent a structural question first: "Which files handle user login, and what do they call?" Expected result: an answer that names real paths from your repository. Close the session, open a new one and ask a related question, for example "What did we say about login?" Expected result: the agent still has the earlier project context instead of asking you to re-explain everything.

A quick sanity check you can keep as a habit:

- [ ] The client shows the server as connected.
- [ ] The first answer contains real file names from your repo.
- [ ] A brand-new session still knows project structure.
- [ ] You did not paste your project tree into the chat by hand.

## Possible problems and solutions
![Illustration: Possible problems and solutions](https://ai-release.org/guides/img/kak-dat-ii-agentu-postoyannuyu-pamyat-o-proekte-devmemo-en-3.jpg)


**Problem 1: the client has no MCP option at all.** Symptom: your settings screen has no "MCP" section and no way to add a server, and any config file you edit is ignored. Solution: this matches the stated condition — you need a client with MCP support. Move to Claude Code, Codex, Cursor or another MCP client, then repeat steps 3–5. There is no workaround inside a client that lacks the feature.

**Problem 2: the server shows as failed or immediately disconnects.** Symptom: the server appears in the list but goes red, or the log shows an error of the kind "failed to start server" or "command not found". Solution, in order: (a) use an absolute path to the binary, not a relative one like `./graphicle`; (b) confirm the binary actually exists and is executable — run it once directly in the terminal; (c) if you built from source, make sure the build finished without errors before you registered it; (d) re-check the JSON for a missing comma or quote.

**Problem 3: the agent answers as if it never saw your project.** Symptom: you ask about your code and get a generic answer with no file paths, or the agent asks you to paste your code. Solution: verify the path you passed in the server arguments is the real project root, restart the client so the graph is rebuilt, then repeat the two-session test from step 7. A wrong or stale project path is the usual cause.

## FAQ

**Does this work with Cursor?**
Yes — the project states that Graphicle works with Claude Code, Codex, Cursor and any MCP client. You register the same server entry in Cursor's MCP settings and restart the client.

**Do I need an API key?**
Nothing in the project description mentions an API key. The one stated condition is access to a client that supports MCP. If your specific client or hosting setup asks for a key, that requirement comes from the client, not from Graphicle.

**Can I use it with a client that does not support MCP?**
No. The description is explicit: the only condition for access is a client with MCP support. Without it there is no channel for the code graph and memory to reach your agent.

**Is it free, and what are the system requirements?**
Not published. The project description does not disclose installation details, license terms or system requirements, so read the repository at `Graphicle-AI/graphicle` for those before you plan a rollout.