Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Devs are using Memory Bank as a project architecture and planning tool before they write any code. "I prefer starting in Cline, using Memory Bank to build out the context files as a roadmap, and letting Cline take the wheel." How to use Memory Bank for project planning 🧵

96,628 Aufrufe • vor 1 Jahr •via X (Twitter)

10 Kommentare

Profilbild von Cline
Clinevor 1 Jahr

1/ Traditional project planning forces you to switch contexts between planning tools and coding. Memory Bank eliminates this by embedding your roadmap directly in your codebase -- where both you and Cline can access it.

Profilbild von Cline
Clinevor 1 Jahr

2/ Start by defining your high-level goals in Then let Cline populate the technical architecture in By the time you reach you have a complete blueprint before writing a single line of code.

Profilbild von Cline
Clinevor 1 Jahr

3/ The real magic happens when Cline references its own roadmap while coding. It's not just following orders - it's understanding the WHY behind each component, leading to more coherent implementations that align with your original vision.

Profilbild von Cline
Clinevor 1 Jahr

4/ Cline users report this approach creates an "autopilot coding" experience. One user compared it to "driving on the autobahn: you burn through fuel faster, but you get where you're going much quicker."

Profilbild von Cline
Clinevor 1 Jahr

5/ Unlike static planning docs, Memory Bank evolves as your project does. As new patterns emerge during development, Cline updates the roadmap automatically. Your documentation is always in sync with your code.

Profilbild von Cline
Clinevor 1 Jahr

6/ The productivity boost comes from eliminating the mental overhead of context switching. Cline knows the plan, executes against it, and handles the documentation updates - creating a seamless loop from planning to implementation.

Profilbild von Cline
Clinevor 1 Jahr

Interested in using Memory Bank? Here are the docs:

Profilbild von GitProtect.io
GitProtect.iovor 2 Jahren

Automated GitHub, GitLab, Bitbucket and Jira backups, security compliance, data migration and every-scenario-ready Disaster Recovery for 360 cyber resilience. Schedule a custom demo or try 14 days for free.

Profilbild von Simo-Pekka Kiihamäki
Simo-Pekka Kiihamäkivor 1 Jahr

How do you use Cline with large codebases? I find it hard to have it really scan through all files. It seems to be superficial and complete the task early

Profilbild von No me importa nada ⭐⭐⭐
No me importa nada ⭐⭐⭐vor 1 Jahr

implement darg and drop for the folder context

Ähnliche Videos

New short course: LLMs as Operating Systems: Agent Memory, created with Letta, and taught by its founders Charles Packer and Sarah Wooders. An LLM's input context window has limited space. Using a longer input context also costs more and results in slower processing. So, managing what's stored in this context window is important. In the innovative paper MemGPT: Towards LLMs as Operating Systems, its authors (which include the instructors) proposed using an LLM agent to manage this context window. Their system uses a large persistent memory that stores everything that could be included in the input context, and an agent decides what is actually included. Take the example of building a chatbot that needs to remember what's been said earlier in a conversation (perhaps over many days of interaction with a user). As the conversation's length grows, the memory management agent will move information from the input context to a persistent searchable database; summarize information to keep relevant facts in the input context; and restore relevant conversation elements from further back in time. This allows a chatbot to keep what's currently most relevant in its input context memory to generate the next response. When I read the original MemGPT paper, I thought it was an innovative technique for handling memory for LLMs. The open-source Letta framework, which we'll use in this course, makes MemGPT easy to implement. It adds memory to your LLM agents and gives them transparent long-term memory. In detail, you’ll learn: - How to build an agent that can edit its own limited input context memory, using tools and multi-step reasoning - What is a memory hierarchy (an idea from computer operating systems, which use a cache to speed up memory access), and how these ideas apply to managing the LLM input context (where the input context window is a "cache" storing the most relevant information; and an agent decides what to move in and out of this to/from a larger persistent storage system) - How to implement multi-agent collaboration by letting different agents share blocks of memory This course will give you a sophisticated understanding of memory management for LLMs, which is important for chatbots having long conversations, and for complex agentic workflows. Please sign up here!

Andrew Ng

201,127 Aufrufe • vor 1 Jahr

HERMES AGENT CAN SHARE MEMORY WITH CODEX AND CLAUDE CODE THROUGH HINDSIGHT. ONE MEMORY BANK. ONE AGENT REMEMBERS, EVERY OTHER AGENT KNOWS. the problem: you use Hermes for orchestration. Codex for coding. Claude Code for debugging. each has its own memory. switch between them and you explain the same project three times. Hindsight fixes this. one shared memory bank that every agent reads and writes to. tell Codex: "the test color for this project is purple." switch to Hermes. ask: "what test color did I pick?" Hermes answers: "purple." no copy-paste. no re-explaining. instant recall. HOW IT WORKS: Hindsight runs as a Docker container on your machine. self-hosted. your data stays local. an LLM powers the memory processing (retain, recall, reflect). RETAIN: extracts facts from your conversations. entities, decisions, preferences, project context. saved to the memory bank automatically. RECALL: when you ask a question, Hindsight pulls from semantic search, keywords, graph connections, and temporal data. fused into one answer. REFLECT: deeper reasoning layer. connects memories across sessions. identifies patterns in your work. produces observations that get smarter over time. CONNECT TO HERMES: Desktop app: Settings → Memory and Context → switch provider from Namosin to Hindsight. set API URL to your local Docker container. set bank ID. done. CLI: hermes memory setup → select Hindsight. verify: hermes memory status should show: provider: hindsight, installed, available. CONNECT TO CODEX: npx hindsight-coding-agents install codex \ --self-hosted --server this installs lifecycle hooks: initialize memory on session start. recall context during work. retain the session when done. enable hooks in Codex: Settings → Hooks → trust all three. CONNECT TO CLAUDE CODE (same command): npx hindsight-coding-agents install all "all" connects every detected agent on your machine. Claude Code, Codex, Cursor, and others. one command. every agent shares the same bank. TAGS FOR FILTERING: every memory gets tagged by harness (Hermes, Codex, Claude Code) and optionally by project name. in the Hindsight control plane: filter by harness. see only Hermes memories. or only Codex memories. or search across everything. soft partitions inside one bank. not hard walls. cross-reference when you need to. ONE BANK OR MANY: one global bank: solo dev, related projects. all agents share everything. patterns emerge across projects. per-project banks: unrelated codebases. each project gets its own memory. no cross-contamination. your call. start with one. split when projects diverge. KNOWLEDGE PAGES (v0.9.0): Hindsight auto-generates living summaries from your accumulated memories. components, concepts, conventions, decisions. not static docs. projected from real agent conversations. auto-refresh as new memories land. WHAT TO KNOW: self-hosted via Docker. your data never leaves your machine. backup system built in (admin CLI + scheduled exports). works with any LLM (local Ollama, OpenAI, Codex subscription). memory defense: redact or block sensitive content automatically. 33,000+ memories accumulated in ~10 days of normal use.

YanXbt

29,200 Aufrufe • vor 18 Tagen