Open Source • Benchmarked • 100% Local

Memory that learns what works.

Not just what's similar—what actually helped. Say it worked. Say it didn't. The AI remembers. 100% private and local.

Get Started - $9.99 → View on GitHub

Works with popular AI tools like Claude Code and Cursor. Your memory stays on your computer.

Gets smarter over time
Fast memory lookup
Smaller context, lower costs
Open Source

Pre-built: Ready to run, no setup • Build yourself: Free, some setup required

100% Local
Open Source
Benchmarked

The Problem With AI Memory Today

Most AI memory finds things that sound similar to your question.
But sounding similar doesn't mean it helped you before.

Here's an example:

You ask your AI: "What's a good restaurant for a date night?"

Your AI remembers two places you've tried before:

Memory A:

"That new romantic sushi place downtown"

You went there - food was disappointing

Memory B:

"The Italian place on Main Street"

You loved it - amazing experience

Regular AI picks Memory A because "romantic" and "downtown" sound like good date words.
Roampal picks Memory B because it remembers you actually had a great time there.

How does it know what worked?

Just talk naturally. The AI reads your response, determines if you were satisfied, and scores the memory in Roampal. No buttons to click, no ratings to give - it learns from the conversation itself.

We tested this:

Questions designed to trick the AI into giving the wrong answer.

Approach Got It Right Improvement
Standard AI search 10% -
+ Smarter ranking 20% +10 pts
+ Learning from outcomes 50% +40 pts

Smarter ranking helps a little. Outcome tracking helps 4× more.

It gets better the more you use it

We measured how well it finds the right answer over time.

10%

Cold start (0 uses)

100%

As you use it

4×

Better than ranking alone

The more you use it, the better it gets at finding what actually helps you.

Why this matters:

Better answers with less noise. Roampal only retrieves what's proven helpful, not everything that sounds related. That means lower API costs, faster responses, and more accurate answers.

Technical details for researchers

Coding (30): p=0.001, d=7.49 • Finance (100): p<0.001, χ²=98 • Learning: p=0.005, d=13.4
Full methodology & reproducible benchmarks

Your AI Gets Smarter Over Time

Traditional AI memory gets fuller. Roampal gets smarter.

Remembers What Worked

Auto

Good advice rises to the top. Bad advice sinks. Automatically.

Organized Memory

Smart

Short-term, long-term, permanent - your memories organized by how often you need them

Learns Your Patterns

Adapts

Learns which tools work, which topics connect, and what advice helps you specifically

Instant Responses

<100ms

Searches your memories in milliseconds. All on your machine.

100% Privacy

Local

Everything stays on your machine. No cloud. No tracking. Works offline.

How It Works

Handles Confusing Situations
Even when there's lots of similar-sounding info, still finds the right answer 80% of the time because it prioritizes what actually helped.
Knows Where to Look
Learns which memories are useful for which questions. Ask about recipes? Checks your food notes. Ask about work? Checks your project notes.
Remembers What Worked
When something helps you, it remembers. When something doesn't, it learns from that too. Next time, helpful stuff comes first.

All of this is tested and verified. Want to see the details?

View Benchmark Source Code

Tired of AI That Never Learns From Its Mistakes?

They Don't Learn From Outcomes

Cloud AI remembers what you say—but not what actually worked vs failed with you.

You Start From Zero Daily

Re-explain your stack, your goals, your context. Every. Single. Day.

Your Data Lives on Their Servers

Memory features behind paywalls. Your conversations stored in the cloud. Forever.

Traditional AI

User: "How do I fix X?"
AI: "Try A"
User: "Didn't work"
AI: "Try A" (again)

Roampal

User: "How do I fix X?"
AI: "Try A"
User: "Didn't work"
AI: "Try B (A failed before)"

Three Ways Roampal Knows You Better Than Any AI

Remembers Who You Are

Tell it something once. It remembers forever. Your preferences, your goals, the things that matter to you.

You: "I'm vegetarian and allergic to nuts"

A week later...

AI: Never suggests recipes with meat or nuts

Knows Your Documents

Upload your files - notes, PDFs, spreadsheets, whatever. Ask questions and get answers based on YOUR stuff.

You upload: travel plans, meeting notes

You ask: "What time is my flight?"

AI: Checks your travel doc and tells you

Learns What Actually Works

When advice helps you, it remembers. When it doesn't, it learns from that too. Over time, it gets better at helping YOU.

AI suggests: "Try the Italian place" → You loved it!
AI suggests: "Try the sushi spot" → Wasn't great

Next time you ask for restaurants:
AI: Suggests places like the Italian one

See It Learn In Real-Time

1

Bad Advice Fails

What's a good restaurant for a date night?

How about that new sushi place downtown?

Went there, wasn't great...

Recording: FAILED Bad advice sinks ↓
2

Good Advice Works

Any other suggestions?

There's that Italian place on Main Street - quiet atmosphere, great reviews.

Perfect! Had an amazing time there.

Recording: WORKED Good advice rises ↑
3

Next Time: Instant Recall

Need a restaurant recommendation for tonight

Past Experience
  • Sushi place downtown: Didn't work out
  • Italian place on Main St: Loved it

Based on what you enjoyed last time, I'd suggest the Italian place on Main Street again, or something similar in that area.

What Makes This Different

Learns What Works For You

Keeps track of which solutions actually help with YOUR problems. The more you use it, the better it gets at helping you.

You: "Can't fall asleep"
AI: "Try meditating before bed" → It worked!

A week later...
You: "Can't fall asleep again"
AI: Remembers meditation worked → suggests it first

Watch It Work

See the AI search memory, create notes, and stream responses in real-time. Full transparency into what it's doing.

You can see exactly what the AI is doing:
Searching your memories... → Found 3 helpful things... → Writing answer...

Cross-Conversation Memory

Remembers your preferences and learned patterns across ALL conversations. No need to repeat yourself.

Today: "Gift ideas for Mom"
AI remembers: She loves gardening (from a chat last month)
Suggests: Gardening-related gifts

How Memories Are Organized

How Memories Move From New to Permanent

Working (24h)
Current context
Used successfully twice
↓
History (30d)
Recent conversations
Helped you many times
↓
Patterns (∞)
Proven solutions
Permanent storage

Permanent Collections (No Promotion)

Memory Bank
Your preferences & context
AI adds these automatically
Books
Reference docs
User-uploaded
Outcome Detection Algorithm

Roampal uses LLM to detect outcomes from natural language:

  • Positive signals: "that worked!", "perfect", "exactly what I needed"
  • Negative signals: "didn't work", "that failed", "not helpful"
  • Implicit signals: Topic changes, abandoning approach, asking similar question
# LLM analyzes conversation and detects outcome
if outcome == "worked":
    score += 0.2  # Positive outcome
elif outcome == "failed":
    score -= 0.3  # Negative outcome
elif outcome == "partial":
    score += 0.05  # Partial success
Learns Your Patterns

Roampal builds 3 interconnected Knowledge Graphs that learn different aspects of your memory:

1. Routing KG - "Where to Look"

Learns which memory collections answer which types of questions.

You ask: "What books did I read about investing?"

System learned: Questions about "books" → books collection (85% success)

Result: Searches books first, skips less relevant collections → faster answers

2. Content KG - "What's Connected"

Extracts people, places, tools, and concepts from your memories and tracks relationships.

Your memories mention: "Sarah Chen works at TechCorp as an engineer"

System extracts: Sarah Chen → TechCorp → engineer (with quality scores)

Result: "Who works at TechCorp?" → finds Sarah even without exact keyword match

3. Action-Effectiveness KG - "What Works"

Tracks which tools and actions succeed or fail in different contexts.

During a quiz: AI uses create_memory() to answer questions

System tracks: create_memory in "recall_test" → 5% success (hallucinating!)

System tracks: search_memory in "recall_test" → 85% success

Result: After 3+ failures, warns AI: "create_memory has 5% success here - use search_memory instead"

Together: Routing KG finds the right place, Content KG finds connected information, Action-Effectiveness KG prevents mistakes. All three learn from real outcomes.

Privacy Architecture

All data stored locally:

  • Vector DB: ChromaDB (local files)
  • Outcomes: SQLite database
  • Knowledge graph: JSON file
  • LLM: Ollama or LM Studio (local inference)

Zero network calls. Zero telemetry.

Cloud Memory vs Local Learning

Regular AI remembers what you say. Roampal learns what actually helps.

Feature Cloud AI Memory Roampal
Memory Type Stores what you say Learns what works
Outcome Tracking No feedback loop Scores every result
Bad Advice Handling Stays in memory Auto-deleted
Pattern Recognition None Tracks success rates per approach
Failure Avoidance No tracking Warns about past failures
Privacy Cloud servers Your machine only
Works Offline No Yes

Different tools for different needs. Use cloud AI for broad knowledge, Roampal for personal learning that compounds over time.

Who Builds With Roampal?

Developers

"Remembers my entire stack. Never suggests Python when I use Rust."

  • Learns debugging patterns that work with YOU
  • Recalls past solutions: "This worked 3 weeks ago"
  • Builds knowledge base of your architecture

Students & Learners

"My personal tutor that remembers what I struggle with."

  • Tracks what concepts you've mastered
  • Adapts explanations to your learning style
  • Builds on previous lessons automatically

Writers & Creators

"Remembers my story world, characters, and tone."

  • Stores worldbuilding details permanently
  • Tracks character arcs across conversations
  • Learns your writing voice over time

Entrepreneurs & Founders

"My business advisor that knows my entire strategy."

  • Remembers your business model and goals
  • Tracks what marketing approaches worked
  • Builds institutional knowledge as you grow
Private Alpha
Limited Early Access
5-Tier Memory
Learns & Remembers
Zero Telemetry
Fully Private

🔗 Connect Any MCP-Compatible Tool

Give any MCP-compatible AI tool access to Roampal's persistent memory. Works with Claude Code, Cursor, Cline, Continue.dev, and any tool supporting the Model Context Protocol.

STEP 1

Open Settings

Click the settings icon in Roampal's sidebar to access configuration options.

Roampal Settings Panel
Integrations Panel
STEP 2

Navigate to Integrations

Go to the Integrations tab. Roampal automatically detects MCP-compatible tools installed on your system.

Works with: Any tool with an MCP config file (Claude Code, Cursor, Cline, Continue.dev, etc.)

STEP 3

Connect to Your Tool

Click Connect next to any detected tool. Roampal automatically configures the MCP integration.

Don't see your tool?

Click Add Custom MCP Client to manually specify a config file path.

Add Custom MCP Client
🔌

Memory Tools Available:
search_memory add_to_memory_bank update_memory archive_memory get_context_insights record_response

STEP 4

Restart Your Tool

Close and reopen your connected tool. Memory tools will be available immediately.

Auto-Discovery

No manual JSON editing required

50+ Languages

Bundled paraphrase-multilingual-mpnet-base-v2, no Ollama needed

Cross-Tool Memory

Memories shared across all connected tools

Works Offline

Fully local after initial setup

Need Help?

Connection not working? Try disconnecting and reconnecting in Settings → Integrations, or reach out to the community for support.

Join Discord Community

Latest Release

v0.2.8 - MCP Security + No Truncation + Update Notifications

Released December 2025

LATEST

MCP security hardening with parameter allowlisting, rate limiting, and audit logging. Full memory content returned everywhere (no more truncation). In-app update notifications. Exit button for clean shutdown.

MCP Security Hardening

Parameter allowlisting blocks signature cloaking attacks. Rate limiting prevents runaway tool loops. Audit logging tracks all MCP tool executions.

No Truncation Policy

Full memory content returned everywhere. Removed all character limits from MCP search results, cold-start context, and internal guidance.

Update Notifications

In-app banner when new versions available. Downloads through Gumroad. Critical updates can force attention.

View Full Details

MCP Security

  • Parameter Allowlisting - Filters arguments to only declared schema parameters, blocking hidden backdoor params
  • Rate Limiting - 50 calls/minute per server prevents runaway LLM tool loops
  • Audit Logging - Append-only JSONL log of all MCP tool executions

UX Improvements

  • Simplified Cold-Start - Just "KNOWN CONTEXT" with bullet list, removed verbose section labels
  • Exit Button - Settings modal has Exit Roampal for clean shutdown, X button hides app (backend stays ready)
  • MemoizedMarkdown - Performance optimization for message rendering

Documentation

Download v0.2.8 - $9.99 View on GitHub

v0.2.7 - Architecture Refactoring

Released December 2025

Monolithic 4,746-line file refactored into 9 focused, testable modules. Facade pattern preserves API while enabling maintainability. 260 tests passing.

9 Focused Services

ScoringService, SearchService, KnowledgeGraphService, RoutingService, PromotionService, OutcomeService, MemoryBankService, ContextService.

39% Code Reduction

4,746 lines → ~2,880 lines through deduplication and cleaner abstractions. Each service is ~150-400 lines.

Zero API Changes

All existing integrations continue working unchanged. Facade maintains public API while delegating to services.

View Full Details

New Service Modules

  • scoring_service.py - Wilson score calculations, smart sorting scoring
  • knowledge_graph_service.py - Triple KG management (Action, Routing, Content)
  • routing_service.py - Collection routing, concept extraction
  • search_service.py - Vector search with reranking
  • promotion_service.py - Memory lifecycle (working → history → patterns)
  • outcome_service.py - Action outcome tracking
  • memory_bank_service.py - User fact storage
  • context_service.py - Cold-start context generation

Testing

  • 237 Unit Tests - Per-service unit tests with mock dependencies
  • 23 Characterization Tests - Captured original behavior as regression safety net
  • 100% Pass Rate - All tests green before and after refactoring

Documentation

Download v0.2.7 - $9.99 View on GitHub
View Previous Releases

v0.2.6 - Unified Learning + Directive Insights + Contextual Embeddings

Released December 2025

Internal LLM now contributes to Action KG (unified learning across all interfaces). get_context_insights outputs actionable prompts. Contextual book embeddings improve retrieval by ~49%.

Unified Action KG

Internal LLM and MCP clients now both contribute to Action-Effectiveness KG. Tracks ANY tool—built-in and external MCP tools.

Directive Insights

get_context_insights now outputs actionable prompts with workflow guidance. Model-agnostic descriptions work across all LLMs.

Contextual Book Embeddings

Book chunks now embedded with "Book: {title}, Section: {section}" prefix. ~49% improved retrieval for ambiguous queries.

View Full Details

Six Parts Summary

  • Part 1: Internal Action KG - Internal LLM now contributes to Action KG
  • Part 2: Document-Level Insights - Aggregate doc success from Action KG examples
  • Part 3: Directive Insights - get_context_insights outputs actionable prompts
  • Part 4: Model-Agnostic Prompts - Workflow-based descriptions for all LLMs
  • Part 5: Contextual Book Embeddings - ~49% improved retrieval
  • Part 6: Action KG Cleanup - Prevent stale doc_ids on book deletion

Technical Details

  • Tracks ANY Tool: Action KG now tracks built-in tools AND external MCP tools (e.g., mcp__github__create_issue)
  • MCP Unified: Both internal and MCP now cache all doc_ids for Action KG tracking
  • Backward Compatible: No migrations, existing data preserved

Documentation

v0.2.5 - MCP Client + Wilson Scoring + Multilingual Ranking

Released December 2025

Roampal can now connect to external MCP tool servers (Blender, filesystem, GitHub, databases). Wilson score ranking ensures proven memories outrank "lucky" new ones. Multilingual smart sorting supports 14 languages.

MCP Client Integration

Connect to external tool servers like Blender, filesystem, GitHub, SQLite, Brave Search. Your local LLM can now use any MCP-compatible tool.

Wilson Score Ranking

Statistical confidence intervals favor proven track records. A memory with 90/100 success now correctly outranks "lucky" 1/1 success.

Multilingual Reranking

14-language smart sorting for international users. English, Spanish, German, French, Chinese, Japanese, Korean, Arabic, and more.

View Full Details

MCP Client Architecture

  • External Tools: Blender, filesystem, GitHub, SQLite, Brave Search, Puppeteer
  • Connection Manager: Spawns and manages stdio connections to MCP servers
  • Tool Discovery: Auto-discovers available tools from connected servers
  • Graceful Degradation: Internal Roampal tools continue if external servers fail

Memory Ranking Improvements

  • Wilson Score: Statistical lower bounds favor proven memories over lucky new ones
  • Balanced Weighting: Proven high-value (80% learned), Failing patterns (30% learned)
  • Uses Counter Fix: All outcomes (worked, failed, partial) now increment uses correctly

New Models Added

  • Llama 4 Scout: MoE 109B (17B active), 10M context, native tool calling
  • Llama 4 Maverick: MoE 401B (17B active), 128 experts, best reasoning
  • Qwen3:32b: Dense 32B with native Hermes tools
  • Qwen3-coder:30b: MoE 30B for coding tasks

UI Improvements

  • Memory Bank: Virtualized list rendering (60fps with 500+ memories)
  • Thinking Filter: LLM thinking tags filtered during streaming (no flash)
  • Chronological: True text/tool interleaving in message display
  • Error Handling: Better model download and context length error messages

Documentation

v0.2.3 - Multi-Format Documents + Smart Model Selection + 100% Benchmark Accuracy

Released December 2025

Upload PDFs, Word docs, Excel spreadsheets, and more. VRAM-aware model selection recommends optimal quality for your GPU. 100% accuracy on 100 adversarial finance scenarios (vs 0% for regular AI search).

8 Document Formats

PDF, DOCX, Excel, CSV, HTML, RTF + existing TXT/MD. Automatic metadata extraction. Semantic search over tabular data.

Smart Quantization

GPU auto-detection recommends optimal model quality for your VRAM. 6 levels from Q2_K to Q8_0. Prevents VRAM overflow.

100% vs 0% Accuracy

100 adversarial personal finance scenarios. Roampal: 100% correct. Regular AI: 0%. 63% fewer tokens per query.

MCP Enhancements

Enriched search results (score, uses, age). Auto-scores retrieved memories based on user outcome. Better LLM integration.

View Full Details

Multi-Format Document Support

  • PDF: Text extraction via PyMuPDF with automatic metadata (title, author)
  • Word (.docx): Preserves heading structure, extracts document properties
  • Excel (.xlsx, .xls): Row-based chunking with column headers, 50 rows per chunk
  • CSV/TSV: Auto-detects delimiters and encoding, semantic search over tabular data
  • HTML: BeautifulSoup parsing for web page ingestion
  • RTF: Legacy document support via striprtf
  • Limitations: No OCR (text-based PDFs only), no password-protected files

VRAM-Aware Quantization Selection

  • GPU Detection: Detects NVIDIA GPUs via nvidia-smi, queries available VRAM
  • Smart Recommendations: Pre-selects highest quality that fits in detected VRAM
  • 6 Quantization Levels: Q2_K (minimal) → Q8_0 (maximum quality)
  • 9 Models: Qwen2.5 (3b/7b/14b/32b/72b), Llama3.2:3b, Llama3.1:8b, Llama3.3:70b, Mixtral:8x7b
  • Visual Indicators: Green checkmark for safe options, red warning for oversized models
  • Provider Protection: Install buttons disabled when Ollama/LM Studio offline

Token Efficiency Benchmark (100 Scenarios)

  • Domain: Personal finance - where bad advice sounds better than good advice
  • Design: Adversarial queries semantically match the WRONG answer
  • Results: Roampal 100/100 correct, Regular AI 0/100 correct
  • Token Efficiency: Roampal 20 tokens/query vs RAG-5 93 tokens/query (4.7x more)
  • Categories: Investing, Retirement, Debt, Insurance, Tax, Real Estate, Behavioral Finance, Common Myths
  • Research Sources: S&P SPIVA, Schwab, DALBAR, Vanguard

MCP Tool Improvements

  • Enriched Results: [collection] (score:0.75, uses:3, last:worked, age:2d) [id:abc123]
  • Auto-Scoring: record_response scores all memories from last search with same outcome
  • Better Integration: Claude Code, Claude Code, Cursor see more actionable metadata

Bug Fixes

  • Backend Cleanup: Python process properly terminates on window close (no more orphans)
  • Data Path: PROD builds correctly use AppData/Roampal/data
  • LM Studio 404: Quantized model names now resolve to HuggingFace downloads
  • Provider Check: Quant modal Install button disabled when provider offline

Documentation

v0.2.1 - Action-Effectiveness KG + Enhanced Retrieval + Benchmarks

Released November 27, 2025

Major intelligence upgrade: 3rd Knowledge Graph learns which tools work in which contexts, state-of-the-art retrieval pipeline (contextual + hybrid + reranking), and comprehensive production validation (40/40 tests, 93% accuracy, sub-100ms).

3rd Knowledge Graph

Action-Effectiveness KG learns which tools work in which contexts. Auto-warns LLM after 3+ uses when patterns emerge.

Enhanced Retrieval

Contextual retrieval + Hybrid search (BM25+Vector) + Smarter sorting. Based on state-of-the-art research techniques.

Statistically Proven

100% vs 0-3% accuracy on 130 adversarial scenarios (p<0.001). 63% fewer tokens per query. Learning improves 58%→93% over time. Sub-100ms latency.

Quality-Based Ranking

Content KG ranks entities by quality (importance x confidence), not just mentions. Authoritative facts surface first.

View Full Details

Action-Effectiveness Knowledge Graph (3rd KG)

  • Tracks: (context_type, action_type, collection) → outcome mappings
  • Learns patterns: Builds success rates per tool per context over time
  • Auto-warns LLM: Injects guidance after 3+ uses to prevent bad patterns
  • Context-aware: create_memory great for teaching, catastrophic for quizzes
  • Production ready: Integrated in agent_chat.py (production) and main.py (MCP)

Enhanced Retrieval Pipeline

  • Contextual Retrieval: LLM adds context before embedding (Anthropic Sep 2024 technique)
  • Hybrid Search: BM25 (lexical) + Vector (semantic) + RRF fusion
  • Cross-Encoder Reranking: BERT reranks top candidates for precision
  • Graceful degradation: Falls back to vector-only if BM25/smart sorting unavailable

Comprehensive Benchmark Suite

  • Roampal vs Vector DB: 100% vs 0-3% on 130 adversarial scenarios (coding + finance)
  • Token Efficiency: 63% fewer tokens per query (~20 vs 55-93) with better accuracy
  • Learning Curve: 58% → 93% accuracy as memory accumulates (p=0.005, d=13.4)
  • Statistical Rigor: Coding p=0.001, d=7.49 • Finance p<0.001, χ²=98
  • All 5 Memory Tiers: books, working, history, patterns, memory_bank
  • Learns Your Patterns: Routing KG, Content KG, Action-Effectiveness KG

Torture Test Suite (10 tests)

  • High Volume Stress: 1000 rapid stores, all doc_ids unique, zero corruption (58.5s)
  • Adversarial Deduplication: 50 similar memories, kept highest quality (5.8s)
  • Score Boundary Stress: 50 oscillations, scores stayed [0.0, 1.0] (0.9s)
  • Capacity Enforcement: 500-item cap enforced correctly (37.1s)
  • Concurrent Access: 5 conversations x 10 stores, zero collisions (1.3s)
  • KG Integrity: Content KG survives memory deletions (1.5s)

Latency Benchmark

  • Results @ 100 memories: p50=64.60ms, p95=77ms, p99=87.71ms
  • Token Efficiency: 112 tokens average per query
  • p95 Latency: 77ms (validated on 100 memories)

Quality-Based Entity Ranking

  • Formula: quality = importance x confidence (per entity)
  • Impact: Authoritative facts beat noise (quality 0.855 vs 0.15 x 10 mentions)
  • Search boost: memory_bank searches boost docs with high-quality entities (up to 50%)
  • Backward compatible: Old entities default to 0.0, no migration required

Organic Memory Recall

  • Auto-surfaces patterns: Checks KG before every LLM response
  • Merged with action-effectiveness: Combined guidance (Content KG + Action KG)
  • Token savings: Reduces need for explicit searches
  • Cross-conversation learning: Patterns from one conversation help future ones

Memory Bank Philosophy

  • 3 layers: User Context (who you are) + System Mastery (how to be effective) + Agent Growth (self-improvement)
  • Problem solved: LLMs were spamming create_memory (236 calls in 120 turns)
  • Solution: Explicit selectivity guidelines in all prompts and tool descriptions
  • Impact: Reduced noise (236 to ~90 calls), better curation

Documentation

  • Comprehensive documentation: BENCHMARKS.md
  • Release notes: RELEASE_NOTES_0.2.1.md
  • Test source: benchmarks/comprehensive_test/ (test_comprehensive.py, test_torture_suite.py, test_latency_benchmark.py)
  • All tests reproducible with mock services (no LLM required)

v0.2.0 - Learning-Based KG Routing + MCP Integration

Released November 5, 2025

Major release featuring intelligent knowledge graph routing that learns which memory collections answer which queries, plus enhanced MCP integration with semantic learning storage.

Learning-Based KG Routing

System learns which collections answer which queries. Measurable routing improvement through outcome-based feedback.

Enhanced MCP Integration

Semantic learning storage with outcome-based scoring. External LLMs (Claude, Cursor) get intelligent routing.

Dual Knowledge Graphs

Routing KG (blue) learns query patterns, Content KG (green) extracts entities. Visualize memory relationships.

Bundled Embedding Model

All users use paraphrase-multilingual-mpnet-base-v2. Works offline, no Ollama required for embeddings.

View Full Changelog

Learning-Based KG Routing

  • Zero hardcoded keywords - learns entirely from query outcomes
  • N-gram concept extraction (unigrams, bigrams, trigrams)
  • Confidence formula: tier_score = success_rate × confidence
  • Three phases: Exploration (all tiers) → Medium (2-3 tiers) → High (1-2 tiers)
  • Safety fallback expands search if <3 results found

MCP Integration

  • record_response now stores semantic summaries (not verbatim transcripts)
  • External LLM judges previous response quality (worked/failed/partial)
  • Dual function: stores current learning + scores previous learning
  • Fixed collections=["all"] bug - now triggers KG routing properly
  • Enhanced outcome detection prompt with edge case handling

Dual Knowledge Graph System

  • Routing KG: Learns query patterns → collection routing (blue nodes)
  • Content KG: Extracts entity relationships from memory_bank (green nodes)
  • Purple nodes represent concepts shared between both graphs
  • Automatic cleanup on memory deletion prevents stale data

UI Enhancements

  • Time-based filtering: All Time, Today, This Week, This Session
  • Sort options: Importance, Recent, Oldest
  • Dynamic header reflects active filters
  • Fixed success rate calculation (successes / (successes + failures))
  • Smooth panel resizing with debounced updates

v0.1.6 - Hotfix Release

Released November 3, 2025

Critical fixes for collection-specific memory search and knowledge graph success rate accuracy.

Collection Search Fixed

AI can now properly target specific memory collections.

Accurate Success Rates

Knowledge graph now shows true success rates.

Enhanced UI

Clearer labels in knowledge graph concept details.

v0.1.5 - Multi-Provider Support

Released October 31, 2025

Major update adding support for both Ollama and LM Studio providers, enhanced model management, and critical performance fixes.

Multi-Provider Support

Use both Ollama and LM Studio. Auto-detects providers and seamlessly switches between them.

Enhanced Model Library

Browse and download models from both providers with unified management interface.

Provider Status

Settings show which providers are running and how many models each has installed.

View Full Changelog

Multi-Provider Support

  • LM Studio Support: Use LM Studio alongside or instead of Ollama
  • Provider Auto-Detection: Automatically detects which providers are running
  • Provider Switching: Switch between Ollama and LM Studio without losing chat context
  • Unified Model Library: Browse and download models from both providers in one interface
  • Provider Status: Settings show active providers and model counts
  • Model Dropdown Filtering: Only shows models for the currently selected provider

Performance & Reliability Improvements

  • Fixed Redundant Memory Searches: AI was searching memory 3 times for the same query - now searches once and reuses results
  • Collection-Specific Memory Search: AI can now target specific memory collections (books, history, patterns) instead of always searching everything
  • Fixed Cancel Button: Cancel button now properly stops generation and cleans up backend tasks

Technical Details

  • Multi-provider architecture with auto-detection
  • New API endpoints for provider detection and management
  • Enhanced error handling and logging throughout backend
  • Performance optimizations for memory search operations

v0.1.0 - Alpha Release

Initial public release

First public alpha featuring 5-tier memory system, outcome learning, knowledge graph, and persistent memory bank.

Key Features
  • 5-tier memory system (Working, History, Patterns, Memory Bank, Books)
  • Outcome tracking and learning from success/failure
  • Knowledge graph with pattern recognition
  • Persistent memory bank for user preferences
  • Document upload (Books) for reference knowledge
  • Cross-conversation memory with ChromaDB
  • Tool-based LLM interaction with memory search
  • 100% local - Ollama integration

Frequently Asked Questions

How is this different from cloud AI memory (ChatGPT, Claude, etc.)?

Cloud AI stores what you say. Roampal learns what works.

Three key differences:

  1. It learns from results: When something helps you, Roampal remembers. When it doesn't work, it learns from that too. Regular AI just stores what you said.
  2. Local-first privacy: Your data stays on your machine. No cloud servers, no recurring subscriptions ($9.99 one-time payment).
  3. True ownership: You own your data, your models, your memory. Export everything anytime. No vendor lock-in.
What models does it support?

Works with many popular AI models:

  • Llama - Meta's free models
  • Qwen - Great for many languages
  • Mixtral - Fast and efficient

Pick the one that works best on your computer. Install from Settings.

Does it work offline?

Yes! After downloading models, Roampal works completely offline. No internet required.

What are the system requirements?

Minimum: 8GB RAM, 10GB free disk space.

Recommended: 16GB RAM and a decent graphics card for faster responses.

How do I export my data?

Easy way: Go to Settings → Export. Pick what you want to backup and download a zip file.

Manual: All your data is stored in regular files on your computer. Just copy the data folder to backup.

Why charge if it's open source?

The code is free on GitHub. The $9.99 gets you:

  • Pre-packaged executable - No Python setup required
  • Bundled dependencies - Everything included
  • Tested build - Guaranteed to work
  • Lifetime updates - All future releases included

Technical users can View on GitHub for free. The $9.99 is for convenience.

Is Roampal's advice always reliable?

No. Roampal uses AI models that can generate incorrect information, hallucinate facts, or reflect training biases.

Always verify critical information from authoritative sources. Do not rely on AI-generated content for:

  • Medical, legal, or financial advice
  • Safety-critical systems or decisions
  • Production code without thorough review
What are the MCP tools and what do they do?

When you connect Roampal to Claude Code, Cursor, or other MCP-compatible tools, they get access to these memory tools:

  • search_memory - Finds relevant memories based on what you're discussing
  • get_context_insights - Quick lookup of what Roampal knows about a topic
  • record_response - Records whether something worked or didn't (this is how Roampal learns)
  • add_to_memory_bank - Stores permanent facts about you (preferences, identity, goals)
  • update_memory - Corrects or updates existing memories
  • archive_memory - Removes outdated information

Your AI uses these automatically during conversation. You don't need to do anything special.

How does Roampal know when something worked?

Just talk naturally. The AI reads your response, determines if you were satisfied, and scores the memory in Roampal.

For example:

  • If you say "thanks, that fixed it" → the memory that helped gets scored higher
  • If you correct the AI → that memory gets scored lower
  • If you move on without comment → no strong signal either way

No buttons to click, no ratings to give. It learns from the conversation itself.

Why Roampal Exists

Roampal is built on a simple idea: software that respects you. No hidden fees, no data collection, no lock-in.

Stop Re-Explaining Yourself

AI that grows with you. Learns from outcomes. Tracks what actually works. 100% local.

Download Pre-built - $9.99 Ready to run • No setup required • Lifetime updates

Pre-built version: Just download and run • Or build yourself for free from the source code