DEV Community: Alfredo Izquierdo

I Love Obsidian. But My AI Can't Use It.

Alfredo Izquierdo — Tue, 14 Apr 2026 19:12:01 +0000

I have over 800 notes in Obsidian. Architecture decisions from two years ago. Meeting notes I forgot I wrote. Debugging logs that saved me more than once. Random 2am ideas that somehow became real features.

Obsidian is my second brain. I genuinely love it.

But here's the thing that's been bugging me for months: every time I open Claude or Cursor to work on something, none of that knowledge exists. My AI has no idea what's in my vault. It doesn't know about the design doc I spent a whole afternoon writing. It doesn't remember the bug I already solved last Tuesday.

I start from zero. Every. Single. Time.

And honestly? That started to feel like a waste.

The Moment That Made Me Think About This

A few months ago I was debugging an auth issue. I knew — I knew — I had written notes about our authentication flow. Token refresh logic, edge cases we'd hit before, the whole thing. It was all in Obsidian, neatly tagged and linked.

But I was in Claude Code. And Claude had no idea any of that existed.

So I did what I always do: I opened Obsidian, searched for the right note, read through it, copied the relevant parts, pasted them into the chat, and gave Claude the context it needed.

It worked. But it took me 15 minutes to do what should've been instant.

And that's when I thought — wait. Why am I the middleman between my notes and my AI? Isn't the whole point of AI to do this kind of thing for me?

Obsidian Is Great. This Isn't About Obsidian.

Let me be really clear: Obsidian is one of the best tools I've ever used.

Local-first. Markdown files I own forever. Links between ideas. A graph view that actually makes me feel like I have my life together. The plugin community is incredible.

For thinking, writing, and organizing my thoughts — nothing comes close.

The problem isn't Obsidian. The problem is that Obsidian was built for me to read. Not for my AI to search.

What Actually Happens Day to Day

If you use both Obsidian and AI tools, you've probably been through this cycle:

You need context. You're working on something and you know there's a note somewhere that would help. Maybe it's a decision log, maybe a spec, maybe something a teammate shared with you months ago.

You become the search engine. You open Obsidian, try to remember the title, search a few keywords, scan through three or four notes, find the right paragraph, copy it, switch back to your AI tool, paste it in.

You lose the flow. By the time your AI has the context, you've spent 10-15 minutes just finding and transferring information. And you have to do it every session.

Some people try Obsidian MCP servers to solve this — community-built plugins that give AI access to your vault. I tried a couple. They work, but they're limited in ways that matter:

Your vault lives on your laptop. Switch devices and the AI can't reach it. Most of them do keyword matching, not meaning-based search — so searching "how we handle payments" won't find your note titled "Invoice Workflow v3." And if Obsidian isn't open, nothing works at all.

It felt close but not quite there.

The Realization: Not All Knowledge Belongs in the Same Place

After months of going back and forth, I started seeing a pattern. The knowledge in my vault is actually two different things:

Stuff that's for me. Draft ideas. Journal entries. Half-baked brainstorms. Reading highlights. Things I need to think through quietly. This is where Obsidian shines — private, messy, personal.

Stuff my AI needs to know. Architecture decisions. Business rules. How the payment system works. What we decided in that meeting last Thursday. The bug pattern we keep hitting. This kind of knowledge needs to be searchable by meaning, available from any tool, and accessible to my team.

I was forcing Obsidian to be both my thinking space and my AI's memory. But those are different jobs. And they need different tools.

So I Built the Other Half

That's how ContextForge started. I wanted something simple: a place where I could save project knowledge and have my AI actually find it when I needed it.

Not a second note-taking app. Not a replacement for Obsidian. Just a memory layer that sits behind my AI tools and gives them access to what they need.

Here's what that looks like in practice:

Instead of copying notes into a chat, I just ask my AI a question. "How does our auth system work?" And it searches my saved knowledge — not by keywords, but by meaning. So even if I never used the exact words "auth system" in my notes, it still finds the relevant docs because it understands what I'm asking.

Instead of losing context between sessions, my AI picks up where we left off. The decisions from last week, the bugs we fixed, the architecture we agreed on — it's all there.

And instead of my knowledge being locked on my laptop, it's accessible from Claude Code, Cursor, Copilot, or Claude Desktop. Same knowledge everywhere. If I'm working from my laptop in a coffee shop or my desktop at home — same context.

The part that surprised me most? When I connected related pieces of knowledge together, the search got dramatically better. I linked our onboarding docs to the welcome email sequence and the CRM setup guide. Now when someone searches "onboarding," they don't just find the obvious doc — they find everything connected to it, even things they didn't know to look for.

How I Use Both Now

My workflow today is pretty simple:

Obsidian is where I think. Quick notes, journaling, brainstorms, reading highlights — anything personal or half-formed stays in my vault.

ContextForge is where my AI remembers. Project decisions, team agreements, architecture docs, debugging insights — anything my AI should know goes here. I just tell it "remember this" and it's saved.

They're not competing. They're complementary. One is for my brain. The other is for my AI's brain.

And if you already have important notes in Obsidian? You can import them directly — ContextForge reads markdown, so your existing notes transfer without any formatting headaches.

If You Want to Try It

Here's the honest version:

Sign up at contextforge.dev — there's a free plan
Install it with npx contextforge-mcp
Import your most important Obsidian notes (the project ones, not your journal)
Connect it to whatever AI tool you use
Start asking your AI questions about knowledge that used to be stuck in your vault

The free plan gives you 200 items and 500 searches per month. That's more than enough to start with your most critical project and see how it feels.

I'm not going to tell you it'll change your life. But the first time you ask your AI a question and it actually knows the answer because you saved it three weeks ago — that moment is pretty satisfying.

Keep Your Vault

This isn't a "ditch Obsidian" article. I still use it every day. It's still my favorite tool for thinking.

But my AI needed its own memory. Something built for search, not for browsing. Something that works across tools and across devices. Something my team can share.

Keep your vault. Love your vault. Just stop being the middleman between your notes and your AI.

ContextForge works with Claude Code, Cursor, GitHub Copilot, and Claude Desktop. Import your Obsidian notes and make them AI-searchable. Free to start at contextforge.dev.

Claude Code vs Cursor vs GitHub Copilot: What Nobody Tells You About Context

Alfredo Izquierdo — Wed, 08 Apr 2026 14:25:23 +0000

Claude Code vs Cursor vs GitHub Copilot: What Nobody Tells You About Context

Every comparison of AI coding tools focuses on the same things: which model is smarter, which autocomplete is faster, which one costs less per month.

Those comparisons are useful. But they miss the thing that actually determines how productive you'll be: how well each tool understands your project — and how much of that understanding survives to your next session.

I've used all three extensively. Here's what I've learned about the comparison nobody makes.

The Comparison Everyone Makes

You've seen the charts. Claude Code uses Opus/Sonnet, Cursor supports multiple models, Copilot runs on GPT-4 and Claude. Cursor costs $20/month, Copilot is $10-19/month, Claude Code uses API credits. One is an IDE, one is a terminal tool, one is a plugin.

This is all true and mostly irrelevant to your daily experience. Because after the first week, the thing that matters most isn't which model generates better code. It's whether your AI tool understands what you're building — and whether it still understands it tomorrow.

How Each Tool Handles Context

GitHub Copilot

Copilot lives inside your editor. It reads your open files, your recent edits, and suggests completions in real-time. Its new agent mode can make multi-file changes and run commands.

What it remembers: The files you have open, your recent edits, and whatever fits in the conversation window. It recently added MCP support, which means it can now connect to external tools and data sources.

What it forgets: Everything, the moment you close the chat. Your next conversation starts completely fresh. Copilot has no built-in way to carry context between sessions. There's no project-level instruction file (though workspace settings help a bit).

Best at: Quick completions while you type. It feels invisible when it works — you barely notice it's there, which is exactly the point.

Cursor

Cursor is a full IDE built around AI. It indexes your entire codebase, understands file relationships, and uses that understanding when you ask questions or request changes. The .cursorrules file lets you set project-level instructions.

What it remembers: Your full codebase (via indexing), your .cursorrules, and the current conversation. Cursor's codebase awareness is genuinely impressive — it can reference files you haven't opened and understand how components connect.

What it forgets: Every conversation starts clean. Your .cursorrules persist, but those are static instructions, not accumulated knowledge. The debugging session where you found a tricky race condition? The architecture decision you made last Tuesday? Gone.

Best at: Working with large codebases. The codebase indexing gives Cursor a real advantage when you need to refactor across multiple files or understand how things connect. Surveys show 68% adoption among developers who use AI coding tools.

Claude Code

Claude Code runs in your terminal. It reads your project files, understands your codebase deeply, and can execute multi-step tasks with real autonomy — running commands, editing files, creating branches. The CLAUDE.md file gives project-level instructions.

What it remembers: Your full project structure, your CLAUDE.md instructions, and the current conversation. Claude's reasoning is deep — it handles complex, multi-step tasks better than the alternatives. The -c flag lets you continue a recent conversation.

What it forgets: Once a session is truly over, the knowledge is gone. CLAUDE.md helps with instructions, but it's a static file — not a searchable, growing knowledge base. The -c continue flag only works for recent sessions, not last month's work.

Best at: Complex tasks that require reasoning across many files. When you need to plan an architecture change, debug a subtle issue, or implement a feature that touches 15 files — Claude Code handles the complexity better than anything else.

The Gap They All Share

Here's what nobody talks about in these comparisons: all three tools have the same fundamental limitation. None of them remember anything meaningful between sessions.

Copilot doesn't know why you chose PostgreSQL over MongoDB
Cursor doesn't remember the three approaches you tried before finding the right one
Claude Code doesn't recall the security concern your team flagged last sprint

Every morning, every tool, every user: you start from scratch. The AI you work with at 5 PM is brilliant and informed. The AI you meet at 9 AM the next day has total amnesia.

This matters more than model quality, autocomplete speed, or pricing. Because the real productivity killer isn't slow code generation — it's the 15-20 minutes you spend re-establishing context at the start of every session.

What MCP Changes

MCP (Model Context Protocol) is a new standard that all three tools now support. Think of it like USB for AI — a universal way to plug external capabilities into any AI tool.

Before MCP, if you wanted your AI to access a database, a project management tool, or a memory system, each tool had its own custom integration. Now, any MCP-compatible tool works with any MCP-compatible service.

This is significant because it means the gap we've been talking about — persistent memory — can be filled by an external tool that works across all three.

Filling the Gap: Persistent Memory

This is where tools like ContextForge come in. It's an MCP server that gives your AI persistent memory — and because it uses MCP, it works with Claude Code, Cursor, and Copilot equally.

The idea:

Save important knowledge as you work (decisions, patterns, debugging notes, business rules)
Search it later using natural language — the search understands meaning, not just keywords
Organize it by projects and categories so it scales as your knowledge grows
Share it across your team so everyone benefits from collective knowledge

Because it's external to all three tools, your memory follows you. Debug something in Claude Code on Monday, and that knowledge is available in Cursor on Tuesday and Copilot on Wednesday. Same knowledge, any tool.

The latest update even includes relationship-aware search — you can connect related items together, and when you search for one topic, related knowledge surfaces automatically.

The Best Setup (What I Actually Use)

Here's what I've landed on after months of experimentation:

Claude Code for complex tasks — architecture planning, multi-file features, deep debugging. Its reasoning is unmatched.

Cursor for daily coding — editing, refactoring, navigating large codebases. The IDE experience is smooth.

Copilot as a background assistant — autocomplete while I type, quick suggestions that keep me in flow.

ContextForge as the memory layer across all three — every insight, decision, and debugging note saved once, searchable everywhere.

This matches the industry trend. Surveys show developers use 2.3 AI tools on average, because each has a sweet spot. The key is making sure knowledge doesn't get trapped inside any single one.

Making Your Choice

If you're choosing one tool:

Copilot if you want something low-friction that works in your existing editor
Cursor if you want the best codebase awareness and IDE experience
Claude Code if you tackle complex, multi-step tasks that need deep reasoning

If you're choosing what matters most for productivity: pick any tool, but add a memory layer. The tool comparison matters less than whether your AI remembers what you taught it yesterday.

ContextForge adds persistent memory to Claude Code, Cursor, and GitHub Copilot via MCP. Free to start at contextforge.dev.

Why Your AI Coding Assistant Forgets Everything (And What You Can Do About It)

Alfredo Izquierdo — Tue, 31 Mar 2026 14:42:55 +0000

Why Your AI Coding Assistant Forgets Everything (And What You Can Do About It)

You spend an hour working with your AI assistant. You explain your project, your tech stack, your naming conventions, the bug you're chasing. By the end of the session, it knows everything. It's helping you like a senior teammate.

Then you close the window.

Next time you open it, your AI has no idea who you are. The project, the bug, the conventions — all gone. You start from zero.

If this sounds familiar, you're not alone. A 2025 study by Qodo found that 65% of developers report their AI assistants miss relevant context when working on real tasks. And the number one reason? The AI simply doesn't remember what came before.

The Amnesia Problem

Think of it like hiring the most talented assistant in the world. They're brilliant, fast, and can help with almost anything. But every morning they walk in with zero memory of yesterday. They don't know your name, your project, or the three hours you spent explaining the billing system.

That's how every major AI tool works today — ChatGPT, Claude, Cursor, Copilot. The conversation starts, knowledge builds up, and then the session ends and everything disappears.

This isn't a bug. It's how these tools are designed. Each conversation is independent. There's no built-in way for your AI to carry knowledge from one session to the next.

Why Context Windows Don't Solve This

You might have heard that newer AI models have huge context windows — Claude can handle up to a million tokens, GPT-4 handles 128K. That sounds like a lot of memory.

But context windows are more like a desk than a filing cabinet. A big desk lets you spread out more papers while you're working, but when you leave for the night, someone clears the desk completely. The papers are gone.

What's worse, research shows that even during a single long session, AI tools get worse over time. The attention gets diluted. Instructions you gave at the beginning carry less weight by message 80 than they did at message 10. Developers on Reddit and Hacker News call this "context degradation" — and it's one of the most common frustrations people report.

The cruel irony: the obvious fix — starting a fresh conversation — immediately destroys all the context you built up.

What Most People Try (And Why It Falls Short)

Developers have come up with workarounds. Some are clever. None are great.

Copy-pasting context into every session. You keep a document with your project description, architecture notes, and rules. Every new conversation starts with a wall of text. It works, sort of — but it's tedious, eats up your context window, and you have to manually keep that document updated.

CLAUDE.md and .cursorrules files. These are project-level instruction files that your AI reads at the start of each session. They're better than copy-pasting because they're automatic. But they're static text files — no search, no organization, no way to store hundreds of knowledge items, and they don't sync across different tools.

Relying on git history. Your AI can read recent commits, but git history tells you what changed, not why. The reasoning, the tradeoffs, the things you tried that didn't work — none of that lives in a commit message.

Just living with it. Many people don't even realize there's an alternative. They accept the 10-20 minute "re-onboarding" at the start of every session as the cost of using AI.

What Actually Works: Persistent Memory

The real solution is giving your AI a memory that persists between sessions. Not a bigger desk — a filing cabinet.

The idea is straightforward:

When you learn something important, you save it
When you need it later, you search for it — in plain language, not exact keywords
Your AI pulls up the relevant knowledge automatically, no matter how many sessions have passed

This turns your AI from a brilliant amnesiac into a teammate that actually accumulates knowledge over time. The more you save, the more useful it gets.

How This Works in Practice

A few tools have emerged to solve this problem. One of them is ContextForge, which works as a memory layer for Claude Code, Cursor, GitHub Copilot, and Claude Desktop.

Here's what the workflow looks like:

Saving knowledge:

You just solved a tricky problem. Instead of hoping you'll remember it next week, you tell your AI:

"Remember this: the billing webhook requires the signature header to be base64-decoded before validation."

That's it. Saved permanently, searchable later.

Finding knowledge:

Three weeks later, you're debugging something related. You ask:

"What do we know about the billing webhook?"

Your AI searches your memory and pulls up exactly what you saved — plus anything related. You don't need to remember the exact words. The search understands meaning, so "payment processing issues" would find your billing webhook note too.

Organizing knowledge:

As your saved knowledge grows, it stays organized in Projects and Spaces — like folders within folders. Your backend notes stay separate from your frontend notes. Your personal project stays separate from your team's shared knowledge.

The Compound Effect

The real power isn't in any single saved item. It's in the accumulation.

After a week, your AI remembers your recent decisions. After a month, it knows your architecture, your conventions, your common pitfalls. After three months, it has institutional knowledge that would take a new team member days to absorb.

And if you're working with a team, the effect multiplies. Everyone's saved knowledge becomes searchable by everyone else. Your senior engineer's debugging insights are available to your junior developer. No one has to re-discover what someone else already figured out.

Getting Started

If you want to try persistent memory:

Sign up at contextforge.dev (free tier available)
Install with one command: npx contextforge-mcp
Connect it to your AI tool of choice
Start saving things you'd normally lose between sessions

The free plan gives you 50 saved items and 100 searches per month — enough to feel the difference in your first week.

But regardless of which tool you use, the principle is the same: stop letting your AI forget everything you teach it. The 15 minutes you spend re-explaining your project every session add up to hours every week and days every month.

Your AI is powerful. Give it a memory, and it becomes indispensable.

ContextForge works with Claude Code, Cursor, GitHub Copilot, and Claude Desktop. Free to start.

contextforge.dev

The Missing Layer Between You and Your AI Coding Assistant

Alfredo Izquierdo — Tue, 24 Mar 2026 15:30:00 +0000

The Missing Layer Between You and Your AI Coding Assistant

If you use AI tools like Claude, ChatGPT, Cursor, or GitHub Copilot to help you work, you've probably noticed something frustrating: every time you start a new conversation, your AI has no idea who you are.

It doesn't remember what you worked on yesterday. It doesn't know your project. It doesn't recall that bug you spent three hours fixing last week. You have to explain everything from scratch. Every. Single. Time.

That's the problem I got tired of. And that's why I built ContextForge.

The Problem: Your AI Has Amnesia

Think of it like this. Imagine you hire an incredibly talented assistant. They're fast, smart, and can help you with almost anything. But every morning when they show up to work, they've completely forgotten everything — your name, your company, what you're building, what happened yesterday.

That's exactly what working with AI tools feels like today. The conversation ends, the memory is gone.

For me, this meant:

15-20 minutes wasted at the start of every session re-explaining my project
Repeating the same context about my tech stack, business rules, and decisions
Losing valuable insights — solutions I found yesterday were gone today
Onboarding friction — every team member had to re-teach the AI from zero

It doesn't sound like a lot. But multiply that across every session, every day, across a team — and it adds up to hours of lost productivity every week.

The Solution: Give Your AI a Memory

ContextForge is a memory layer for your AI tools. It works with Claude Code, Cursor, GitHub Copilot, and Claude Desktop. The idea is simple:

Anything you want your AI to remember, you save. Anything you need later, you search.

Here's what that looks like in practice:

Starting your day:

You open your AI tool and ask:

"What were we working on last week?"

Instead of a blank stare, your AI pulls up your recent work — the features you were building, the bugs you fixed, the decisions you made. You're productive in 30 seconds instead of 20 minutes.

Saving what you learn:

You just figured out something important — maybe a tricky business rule, a workaround for a tool, or a decision your team agreed on. You tell your AI:

"Remember this: client invoices must be generated before the 5th of each month, or the billing system flags them as late."

Done. That knowledge is now saved permanently and searchable by anyone on your team.

Switching between projects:

You jump from one project to another. Instead of re-explaining everything, your AI already knows the context for each project — how it's structured, what the priorities are, what's been decided. The switch is instant.

How the Search Works (The Part That Makes It Useful)

Saving knowledge is only half the story. The other half is finding it when you need it.

ContextForge uses smart search. You don't need to remember exact words or file names — you just describe what you're looking for in plain language.

"How do we handle client payments?"

"What was that issue with the email notifications?"

"Find everything related to the onboarding process"

The search understands meaning, not just keywords. So if you saved something titled "Invoice generation workflow" and you search for "billing process," it'll still find it because the concepts are related.

You can also narrow things down:

Search within a specific project or workspace
Filter by tags like "urgent," "design-decision," or "bug"
Set how closely results need to match your question

Everything is organized into Projects (your different initiatives) and Spaces (categories within a project, like "Design," "Bugs," "Architecture"). So your knowledge stays tidy as it grows.

The New Feature: Search That Follows Connections

Here's what we just shipped, and it's a game-changer.

The old way: You search for "onboarding" and you get results that mention "onboarding." But what about that welcome email sequence you saved separately? Or that CRM setup guide that's directly related? If those didn't use the word "onboarding," they wouldn't show up.

The new way: ContextForge now follows the connections between your saved knowledge.

How It Works

When you save knowledge, you can link related items together. Just tell your AI:

"Connect the welcome email sequence to the onboarding process"

"Link the security audit to the payment system architecture"

You're building a web of connected knowledge — like a personal Wikipedia for your projects.

What This Means for Search

Now when you search for "onboarding," ContextForge does something smart:

Finds direct matches — anything that talks about onboarding
Follows the connections — discovers related items that are linked to those matches, even if they never mention "onboarding"

So your search for "onboarding" might return:

Direct results:

Client Onboarding Process (89% match)
Onboarding Checklist (76% match)

Discovered through connections:

Welcome Email Sequence — connected to the onboarding process
CRM Setup Guide — derived from the onboarding checklist

You found things you didn't even know to search for. That's the power of connected knowledge.

Why This Matters for Teams

This is where it gets really powerful. When one person saves knowledge and connects it to related topics, everyone on the team benefits.

Your experienced team member documents how the payment system works and links it to the security requirements, the compliance rules, and the third-party integrations. Now when someone new searches "payment processing," they don't just get one document — they get the full picture, including context they wouldn't have known to look for.

The more connections your team creates, the smarter every search becomes. Knowledge compounds over time.

Real Impact

After three months of using ContextForge in my daily workflow:

Starting a work session: from ~15 minutes of setup to ~30 seconds
Investigating past issues: from ~45 minutes of digging to ~10 minutes of searching
Switching between projects: from ~10 minutes of context loading to instant
Bringing new team members up to speed: from days to hours

That's roughly 1-2 hours saved every day. Not through any trick — just by not having to repeat myself.

Getting Started

If you want to try it:

Create a free account at contextforge.dev
Get your API key from the dashboard
Install it with one command: npx contextforge-mcp
Connect it to your AI tool (Claude Code, Cursor, Copilot, or Claude Desktop)
Start saving knowledge and let it build up over time

The free plan includes 50 saved items, 100 searches per month, and 3 workspaces. That's enough to see the difference in your first week.

The Bottom Line

AI tools are incredibly powerful, but they have a fundamental gap: they forget everything between conversations.

ContextForge fills that gap. Save what matters. Connect related knowledge. Search it naturally. And let it grow smarter over time — for you and your whole team.

The relationship-aware search we just launched makes this even better. Now when you search, you don't just find what matches your words — you find everything that's connected to it.

Because the best knowledge isn't just the thing you searched for. It's the thing you didn't know you needed.

ContextForge Memory works with Claude Code, Cursor, GitHub Copilot, and Claude Desktop. It's free to start.

contextforge.dev | GitHub | npm

GitHub Copilot Now Supports MCP — Here's How to Give It Persistent Memory

Alfredo Izquierdo — Tue, 17 Mar 2026 16:00:00 +0000

GitHub Copilot just got MCP support. That means you can now connect external tools directly to Copilot's Agent Mode in VS Code.

One thing you can do with this: give Copilot memory that persists across sessions.

The problem

Every time you start a new Copilot chat, it starts from zero. It doesn't know your architecture. It doesn't remember the decision you made last week about the auth flow. It doesn't know that your team uses Zustand instead of Redux, or that the billing module has a quirk with European tax codes.

You explain. Again. And again.

This isn't a minor inconvenience. For complex projects, re-establishing context is the biggest time sink when working with AI coding agents.

What changed

GitHub shipped MCP (Model Context Protocol) support for Copilot in VS Code. MCP is an open protocol that lets AI tools connect to external servers — databases, APIs, custom tools.

This means Copilot can now use tools beyond its built-in capabilities. Including tools that give it memory.

How it works

I built ContextForge, an MCP server that gives AI agents persistent memory. It works with Claude Code, Claude Desktop, Cursor, and now GitHub Copilot.

The setup takes about 3 minutes.

Step 1: Create a free account

Go to contextforge.dev and sign up. Create an API key from the dashboard.

Step 2: Add the MCP config

Create a .mcp.json file in your project root:

{
  "servers": {
    "contextforge": {
      "command": "npx",
      "args": ["-y", "contextforge-mcp"],
      "env": {
        "CONTEXTFORGE_API_KEY": "your-api-key-here"
      }
    }
  }
}

Or add it globally in your VS Code settings.json:

{
  "mcp": {
    "servers": {
      "contextforge": {
        "command": "npx",
        "args": ["-y", "contextforge-mcp"],
        "env": {
          "CONTEXTFORGE_API_KEY": "your-api-key-here"
        }
      }
    }
  }
}

Step 3: Use Agent Mode

Open Copilot Chat in VS Code and switch to Agent Mode. ContextForge tools are now available.

That's it.

What you can do with it

Once connected, Copilot can:

Save context as you work:

"Remember that our auth uses JWT with 1-hour token expiration and refresh tokens stored in HTTP-only cookies"

Recall it in any future session:

"How does our authentication work?"
→ Found 3 results: JWT auth with refresh tokens in HTTP-only cookies... (94% match)

Sync your Git history:

"Sync my recent commits to memory"
→ Synced 47 commits and 8 PRs

Track tasks:

"Create a task: Fix auth token refresh bug, priority high"

Search with natural language:

"What decisions did we make about the database schema?"

The key insight: this memory persists. Close VS Code, switch machines, start a new chat — the context is still there.

Why this matters

Large context windows help, but they don't solve the persistence problem. Claude's 1M token window is impressive. But when the session ends, that context is gone.

Persistent memory is different. It's the accumulated knowledge about your project — architecture decisions, naming conventions, debugging notes, deployment quirks — that you build up over weeks and months.

Think of it as the difference between RAM and a hard drive. You need both.

Works everywhere

The same memory syncs across all your tools:

GitHub Copilot — Agent Mode in VS Code
Claude Code — Terminal workflow
Claude Desktop — Rich conversations
Cursor — AI-assisted editing

Save a decision in Claude Code, recall it in Copilot. The memory follows you, not the tool.

Try it

ContextForge has a free tier — no credit card required. Setup takes under 3 minutes.

Website: contextforge.dev
Docs: contextforge.dev/docs
npm: npm install -g contextforge-mcp

If you're already using Copilot with Agent Mode, adding persistent memory is one .mcp.json file away.

I built ContextForge because I got tired of re-explaining my codebase to my AI agent every morning. If you've felt the same frustration, give it a try.

Claude Now Remembers 5x More — But It Still Forgets You Tomorrow

Alfredo Izquierdo — Sat, 14 Mar 2026 02:27:00 +0000

Last Tuesday I was three hours deep into a refactor. Not the fun kind — the kind where you're untangling years of tech debt and every file you touch reveals two more that need fixing.

But Claude and I were in the zone. We'd mapped out the dependency chain, figured out the migration order, and even caught a subtle race condition that would've blown up in production. It was one of those sessions where you feel like you're pair programming with someone who genuinely gets it.

Then my laptop died.

I plugged it in, reopened Claude, and typed "ok where were we?"

"I'd be happy to help! What are you working on?"

Three hours. Gone. Not because Claude isn't smart enough to remember — but because that's just how conversations work. They end.

So About That 1 Million Token Thing

You've probably seen the news. Opus 4.6 now ships with a 1M token context window. Five times bigger than before, same price. And honestly? It's a massive deal.

With a million tokens you can hand Claude your entire codebase and it won't blink. It can hold the frontend, the backend, the tests, the deployment configs, and still have room for a lengthy conversation about all of it.

But I want to tell you about something that happened to me after the announcement.

I was scrolling through Twitter and saw someone post: "1M context window means memory tools are officially dead. Why would you need persistent storage when you can just load everything?"

And I laughed. Not because they're wrong about the power of 1M tokens — they're absolutely right. I laughed because I've heard that exact take every single time context windows got bigger. At 8K. At 100K. At 200K. And every time, three weeks later, those same people are frustrated again.

The Filing Cabinet on Your Desk

Let me tell you why.

Last week a developer on our Discord shared something that stuck with me. He said: "I upgraded my desk to one of those giant L-shaped ones. I can spread out every document I need. But I still need my filing cabinet because at 6 PM I have to clear the desk."

That's it. That's the whole thing.

A bigger context window is a bigger desk. You can spread out more. You can see more at once. You can make connections between things that used to require flipping back and forth. All of that is genuinely useful.

But when you close the tab — and you will close the tab — the desk gets cleared.

Your filing cabinet is what makes Monday morning bearable. It's what lets you pick up a project after a week of vacation without spending an hour figuring out where you left off. It's what keeps tribal knowledge from evaporating when someone goes on PTO.

A Wednesday That Changed How I Think About This

Three weeks ago, on a Wednesday, I hit a bug that made no sense. A webhook handler was silently dropping events, but only for one specific customer. The logs showed nothing. The code looked correct.

I was about to start a fresh debugging session when Claude pulled something up from my ContextForge space — a note from January where I'd documented a nearly identical issue. Turns out, that customer's account had been created during a migration window where a timezone offset was slightly wrong, causing their webhook signatures to validate with a one-second drift.

January. Two months ago. In a conversation I'd completely forgotten about.

I fixed the bug in fifteen minutes. Without that note, I would've burned the afternoon — and maybe part of Thursday — tracing through the same path I'd already walked.

That's not something a bigger context window gives you. That's accumulated knowledge paying dividends over time.

What I Didn't Expect

When I first built ContextForge, I thought of it as a note-taking tool for AI. Save stuff, recall stuff. Simple.

But something unexpected happened once teams started using it.

A developer in São Paulo joined a project that three people had been building for four months. Instead of the usual two-hour onboarding call, she connected to the shared ContextForge space and started asking Claude questions. "Why did we choose this auth pattern?" "What's the deal with the legacy billing endpoint?" "Are there any known gotchas with the rate limiter?"

Claude answered all of them. Not from documentation — most of it wasn't documented. From the accumulated memory of four months of conversations, decisions, and debugging sessions that the team had been naturally building up.

She shipped her first PR that afternoon.

That's not a feature. That's a side effect of giving AI a way to accumulate knowledge over time. And it has nothing to do with how big the context window is.

Why 1M Actually Makes Memory Better

Here's the part that surprises people: a bigger context window doesn't make persistent memory obsolete. It makes it more powerful.

Before, with a 200K window, ContextForge had to be surgical about what it surfaced. Only the top 5 most relevant memories could fit alongside your code. Tough choices had to be made.

With 1M tokens? Claude can load your recent commits, your architectural decisions, the debugging notes from last month, AND the full code you're working on — all at once. The memory has room to breathe. Context and memory stop competing for space and start complementing each other.

Bigger desk. Same filing cabinet. Better workflow.

The Honest Take

I'm not going to pretend this article isn't partly about ContextForge. It is. I built the thing, I believe in it.

But the honest truth is this: I've watched developers go through the same cycle over and over. A new model drops, context gets bigger, everyone celebrates, and then slowly the frustration creeps back in. Because the underlying problem — that conversations are temporary but projects are not — never actually goes away with a bigger window.

A million tokens is extraordinary. I genuinely mean that. For the first time, you can have a conversation with Claude where it truly understands your entire codebase at once. That changes what's possible in a single session.

But your project isn't a single session. It's hundreds of sessions spread across months. And somewhere between session 47 and session 48, there's a gap where knowledge falls through. That gap is what persistent memory fills.

ContextForge is free to start. If you've never experienced a Claude that remembers your last conversation, try it once. That's all I ask.

Import Your AI Memory into ContextForge: Claude Code, ChatGPT, and Knowledge Graph

Alfredo Izquierdo — Mon, 09 Mar 2026 22:06:00 +0000

You've been building knowledge with your AI assistant for months — project decisions, API patterns, debugging notes. But that knowledge is scattered across MEMORY.md files, ChatGPT exports, and Knowledge Graph JSONL dumps.

Today, ContextForge lets you import all of it in seconds.

The Problem: Scattered AI Memory

If you use AI coding assistants, your knowledge ends up in different places:

Claude Code saves memory in ~/.claude/projects/*/memory/MEMORY.md
MCP Knowledge Graph server stores entities in memory.jsonl
ChatGPT lets you export conversations as conversations.json
Random Markdown files with notes you copied manually

None of these tools talk to each other. Switch from one to another, and you start from zero.

One Import, All Your Knowledge

ContextForge now supports importing from all major AI memory formats:

Format	File Type	What Gets Imported
Claude Code	`.md`	Each `##` section becomes a knowledge item
MCP Knowledge Graph	`.jsonl`	Entities become searchable knowledge items
ChatGPT	`.json`	Assistant responses extracted automatically
Plain Markdown	`.md`	Sections split by headings
ContextForge JSON	`.json`	Full backup/restore between spaces

How It Works

From the Dashboard (No Code Required)

Open any Space in your dashboard
Click the "Import" button next to "Add Item"
Select your format or just upload a file (auto-detected)
Preview the items that will be imported
Click "Import N Items" — done

Duplicates are automatically detected and skipped using SHA-256 hashing. You won't get repeated items.

From Claude or Cursor (Via MCP)

You can also import directly from your AI assistant:

"Import my MEMORY.md file into the backend-docs space"

Or use the MCP tool directly:

memory_import({
  "format": "claude_memory",
  "data": "## Auth Flow\n- JWT tokens expire in 1 hour\n..."
})

Supported Formats in Detail

Claude Code (MEMORY.md)

Claude Code stores persistent memory in Markdown files at ~/.claude/projects/*/memory/MEMORY.md. Each ## heading becomes a separate knowledge item.

# My Project Memory

## Database Patterns
- Always use connection pooling
- Migrations must be idempotent
- Use RLS for row-level security

## Auth Flow
- JWT tokens expire in 1 hour
- Refresh tokens last 30 days

This file imports as 2 items: "Database Patterns" and "Auth Flow".

MCP Knowledge Graph (.jsonl)

The official @modelcontextprotocol/server-memory package stores entities in a JSONL file. Each entity becomes a knowledge item with its observations as content.

{"type":"entity","name":"ContextForge","entityType":"project","observations":["A SaaS for persistent AI memory","Built with Supabase"]}
{"type":"entity","name":"Auth System","entityType":"component","observations":["Uses JWT with 1h expiry","Refresh tokens in httpOnly cookies"]}
{"type":"relation","from":"ContextForge","to":"Auth System","relationType":"contains"}

Entities are imported as knowledge items. Relations are preserved for future knowledge graph features.

ChatGPT Export (conversations.json)

Go to ChatGPT Settings > Data Controls > Export Data. You'll receive a zip file containing conversations.json.

ContextForge extracts assistant responses from each conversation. Only meaningful content is imported — empty or system messages are skipped.

Export Anytime

Your data is yours. Export from any space in JSON, Markdown, or CSV:

memory_export({
  "format": "json",
  "space_id": "your-space-id"
})

Or just ask your AI assistant: "Export my backend-docs space as Markdown."

Get Started

Sign up at contextforge.dev (free tier available)
Install: npm install -g contextforge-mcp
Open any space and click Import
Upload your MEMORY.md, memory.jsonl, or conversations.json

Stop losing knowledge when you switch tools. Bring everything into one place.

Have questions about importing? Check the full docs at contextforge.dev/docs/import-export or reach out through the dashboard.

ContextForge Now Supports Cursor IDE: Persistent AI Memory Everywhere"

Alfredo Izquierdo — Fri, 06 Mar 2026 20:13:49 +0000

ContextForge Now Supports Cursor IDE: Persistent AI Memory Everywhere

If you've ever wished your AI coding assistant could remember things between sessions — project decisions, API patterns, debugging insights — ContextForge already solved that for Claude Desktop and Claude Code users.

Today, we're excited to announce that ContextForge now officially supports Cursor IDE.

The Problem: AI Amnesia

Every time you start a new chat in your IDE, your AI assistant starts from zero. It doesn't remember:

That architectural decision you explained yesterday
The API endpoint documentation you walked through last week
The bug pattern you already solved twice

You end up repeating yourself. Over and over.

The Solution: ContextForge MCP

ContextForge is a persistent memory layer for AI coding assistants. It works through the Model Context Protocol (MCP) — an open standard that lets AI tools connect to external services.

With ContextForge, your AI assistant can:

Remember knowledge across sessions — save and recall documentation, decisions, patterns
Track tasks — create, assign, and resolve issues without leaving your editor
Organize by projects — keep different codebases' context separate and clean
Search semantically — ask questions in natural language and get relevant stored knowledge
Collaborate — share project memory with your team

Setting It Up in Cursor (3 Minutes)

1. Install ContextForge MCP

npm install -g contextforge-mcp

2. Get Your API Key

3. Configure Cursor

Create or edit ~/.cursor/mcp.json:

{
  "mcpServers": {
    "contextforge": {
      "command": "contextforge-mcp",
      "env": {
        "CONTEXTFORGE_API_KEY": "your-api-key-here"
      }
    }
  }
}

On Windows, the file is at %USERPROFILE%\.cursor\mcp.json.

4. Restart Cursor

That's it. ContextForge tools are now available in Cursor's AI chat.

What You Can Do

Once configured, just talk to your AI assistant naturally:

Save Knowledge

"Remember that our auth flow uses JWT tokens with a 15-minute expiry and refresh tokens stored in httpOnly cookies."

Recall Knowledge

"What do we know about the authentication flow?"

Track Tasks

"Create a task: Refactor the payment module to support Stripe webhooks"

List Tasks

"What are my pending tasks?"

Project Linking

"Link this directory to the 'backend-api' project"

Your AI assistant now has context that persists across sessions, across days, across weeks.

Works Everywhere

ContextForge isn't just for Cursor. The same MCP server works with:

Claude Code (CLI)
Claude Desktop (macOS, Windows, Linux)
Cursor IDE
Any MCP-compatible client

Your memory is synced across all of them. Save something from Claude Code, recall it in Cursor. Create a task in Claude Desktop, resolve it from your terminal.

Free to Start

ContextForge has a free tier that includes:

1 project
50 knowledge items
Semantic search
Task tracking

Upgrade when you need more projects, more storage, or team collaboration.

Get Started

Sign up at context.dev
Install with npm install -g contextforge-mcp
Follow the full guide at context.dev/docs/install-cursor

Stop repeating yourself to your AI assistant. Give it memory.

ContextForge is open to feedback. If you have questions or feature requests, reach out through the dashboard or leave a comment below.

How to Give Claude Persistent Memory with MCP

Alfredo Izquierdo — Tue, 03 Mar 2026 23:36:14 +0000

Every conversation with Claude starts from zero. It doesn't remember the stack you chose last week, the naming conventions you prefer, or the bug you spent three hours debugging yesterday. You explain the same context over and over — and it forgets all of it the moment the session ends.

What if it didn't have to be that way?

With the Model Context Protocol (MCP) and a free tool called ContextForge, you can give Claude persistent memory that survives across sessions. In this tutorial, you'll set it up in under five minutes.

What Is MCP?

The Model Context Protocol is an open standard created by Anthropic that lets AI assistants like Claude connect to external tools and data sources. Think of it as a USB port for AI — it's a universal interface that any tool can plug into.

Without MCP, Claude can only work with what you paste into the conversation. With MCP, Claude can read files, query databases, call APIs, and — most importantly for us — save and retrieve memories from a persistent store.

MCP servers run locally on your machine. Claude communicates with them through a standard protocol, and they handle the actual work of storing data, calling APIs, or whatever the server is designed to do. No data leaves your machine unless the MCP server explicitly sends it somewhere — and ContextForge encrypts everything in transit.

What You'll Need

Node.js 18+ installed on your machine
Claude Desktop or Claude Code (the CLI)
A free ContextForge account (we'll create one in Step 1)

That's it. No Docker, no database setup, no infrastructure to manage.

Step 1: Create Your Free Account

Head to contextforge.dev and sign up with Google. It takes about ten seconds.

Once you're in the dashboard, navigate to Settings → API Keys and click Generate New Key. Copy the key — you'll need it in the next step.

The free tier includes 200 documents, 500 queries per month, and 3 spaces. That's more than enough to get started and see real value.

Step 2: Install the MCP Server

Open your terminal and install the ContextForge MCP server globally:

npm install -g contextforge-mcp

Verify the installation:

contextforge-mcp --version

Now set your API key as an environment variable. Add this line to your shell profile (~/.zshrc, ~/.bashrc, or equivalent):

export CONTEXTFORGE_API_KEY="your-api-key-here"

Then reload your shell: source ~/.zshrc

Step 3: Connect to Claude

This is where MCP connects to Claude. Choose the path that matches how you use Claude.

Option A: Claude Code (CLI) — Fastest

If you use Claude Code, run this single command:

claude mcp add contextforge -- contextforge-mcp

Verify the connection:

claude mcp list
# Expected output: contextforge: ✓ Connected

Done. Claude Code now has access to your persistent memory.

Option B: Claude Desktop

For Claude Desktop, you need to edit a JSON configuration file. The file location depends on your operating system.

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

Linux: ~/.config/claude/claude_desktop_config.json

Open the file (create it if it doesn't exist) and add the ContextForge server:

{
  "mcpServers": {
    "contextforge": {
      "command": "contextforge-mcp",
      "env": {
        "CONTEXTFORGE_API_KEY": "your-api-key-here"
      }
    }
  }
}

Save the file and restart Claude Desktop. You should see ContextForge listed in the MCP tools panel.

Step 4: Save Your First Memory

Now for the fun part. Open a new conversation with Claude and try saving some context about your project:

You: "Remember that our project uses PostgreSQL 16, Next.js 15
with the App Router, and we deploy to Vercel. Our API
prefix is /api/v2 and we use snake_case for database columns."

Claude will use the ContextForge MCP tools to store this as a knowledge item. You can also be more specific:

You: "Save this debugging note: the checkout flow breaks when
the cart has more than 50 items because the payment API
has a line-item limit of 50. The workaround is to batch
into multiple payment intents."

Each piece of knowledge is stored with semantic embeddings, which means Claude can find it later using natural language — not just exact keyword matches.

Step 5: Retrieve It Later

Close the conversation. Open a brand new one. Now ask Claude something that requires the context you saved:

You: "What database do we use and what's our column naming convention?"

Claude will search your ContextForge memory and respond with the exact details you saved — PostgreSQL 16, snake_case columns — even though this is a completely new session.

Try another one:

You: "Is there a known issue with large carts in checkout?"

Claude finds the debugging note you saved earlier and gives you the full context, including the workaround. No more repeating yourself.

What Else Can You Do?

Persistent memory is just the beginning. ContextForge gives Claude a full suite of tools to stay organized across sessions:

Spaces — Organize knowledge into separate containers (one per project, team, or topic)
Projects — Group related spaces together and share them with collaborators
Git sync — Connect a GitHub repo and auto-ingest commits and PRs as searchable knowledge
Tasks — Track issues and to-dos that persist between sessions
Snapshots — Create point-in-time backups of your knowledge base
Team sharing — Invite collaborators to your projects so the whole team benefits from shared context

The Free Tier Is Enough to Start

ContextForge's free plan is generous enough for personal projects and small teams:

200 documents stored
500 queries per month
3 spaces for organization
Semantic search included

If you outgrow the free tier, paid plans start at $8/month and unlock more storage, spaces, git sync, and team collaboration features.

Start Building with Persistent Memory

You now have a Claude that remembers. Every architectural decision, every debugging insight, every team convention — saved once and available forever.

Here's what to do next:

Create your free account
Read the full documentation
Start saving the context that matters most to your workflow

The best time to give Claude memory was when you started your project. The second best time is right now.

Claude Is Brilliant. But Working With Amnesia Gets Tiring.

Alfredo Izquierdo — Mon, 02 Mar 2026 18:36:56 +0000

# Claude Is Brilliant. But Working With Amnesia Gets Old.

If you use Claude every day like I do, you already know this feeling. You open a new session,start typing, and then you pause — because Claude has no idea what you're talking about. Your project, your decisions, that trade-off you made yesterday. All gone.

It's like working with the smartest person in the room, except they wake up every morning with amnesia.

The 20-Minute Tax

After a while, I noticed a pattern. Every morning, before I could do any real work, I had to pay the same tax: 15 to 20 minutes of re-explaining context.

"We decided to restructure this part…"
"We changed direction last week because…"
"The current approach is based on…"

Every single day, the same ritual. And the frustrating part? Once Claude had the context, it was incredible. The bottleneck was never intelligence — it was memory.

The Real Cost Isn't Time

It's flow. You lose momentum before you even start. Instead of continuing where you left off, you're reconstructing. Instead of building, you're briefing. And if you rely on Claude daily — for code, for planning, for thinking through problems — that friction compounds fast.

So I Built Something

I'm a developer. When something frustrates me long enough, I build a fix. That's how ContextForge started

— not as a startup idea, not as a pitch, but as a tool I needed for myself.

The idea is simple: give Claude persistent memory that lives across sessions. ContextForge connects to Claude through the Model Context Protocol (MCP), so Claude can read and write to your memory automatically. You don't copy-paste. You don't manage files. You just work.

Now instead of starting from zero every morning, I just continue.

What It Actually Feels Like

Instead of re-explaining my project, I can ask something like: "What did we decide about the authflow?" — and Claude searches my stored context, finds the previous decision, and brings it back with the reasoning behind it.

I don't need to restate the project. I don't need to summarize yesterday. Claude already knows, because the context is there waiting.

That's the difference. Not a new feature — just the feeling of continuity.

What Changes in Practice

Once continuity exists, everything feels smoother.

Decisions stick. Conversations build on top of previous conversations instead of starting from scratch. You make a decision on Monday, and on Friday Claude still knows why.

Context carries forward. You don't lose track of reasoning. The "why" behind your choices stays accessible, not buried in a chat thread you'll never find again.

You move faster. Less time explaining, more time doing. That 20-minute tax disappears, and you get straight to the work that matters.

You trust the answers more. Because they're grounded in your real project history, not Claude guessing from a blank slate.

It's Not Just "Chat Memory"

ContextForge becomes a working layer for your projects. You can organize knowledge into separate spaces, restore previous states if something goes wrong, track decisions and tasks, share project context with collaborators, and manage everything through a clean web dashboard.

It's not about saving chat messages. It's about keeping continuity — for your projects, your decisions, and the way you work.

The Honest Part

I want to be upfront: this is early. I built ContextForge because I needed it, and I use it every single day. There's no big team behind it, no huge launch campaign, no inflated claims. Just a real frustration and a practical solution.

But I can tell you this — once you get used to not re-explaining your work every morning, it's genuinely hard to go back. That shift from "let me catch Claude up" to "let's keep going" changes how your day starts.

Who This Is For

If any of this sounds familiar, ContextForge might help: you use Claude regularly, you work on ongoing projects, you switch between ideas and need continuity, you hate repeating context, or you want conversations that actually build over time.

You don't need to be a senior developer or a power user. If you've ever thought "I wish Claude remembered this" — that's the use case. That's it.

Try It

There's a free tier — no credit card, no time limit. Install it, connect it to Claude, and see if it changes your workflow.

👉 contextforge.dev
👉 Documentation

If you try it, I'd genuinely love to hear what you think. What works, what doesn't, what's missing. I'm building this in public, and every piece of feedback shapes what comes next.

Continuity is just the beginning.