Unabyss Cross-LLM Memory Pipeline — MCP-Native Context Layer for Claude

SECTION 1 — BYLINE

Author: Deepak Bagada · CEO at SaaSNext · dailyaiworld.com
Published: July 18, 2026 · Estimated read: 11 minutes
Difficulty: Beginner · Tools: Unabyss · Claude · GPT · Cursor · Claude Code · MCP protocol

The TL;DR: A single npx unabyss init && npx unabyss start gets you a cross-LLM memory layer that persists context across Claude, GPT, Cursor, and Claude Code. This guide walks the full install, app connections, permission configuration, MCP integration, CLI usage, and multi-client setup — with ROI tables, workflow patterns, and honest limitations.

SECTION 2 — EDITORIAL LEDE

#1 Product of the Day on Product Hunt on July 17, 2026. Unabyss landed with 582 upvotes and 1.9K followers on day one — a strong signal that the problem of context fragmentation across AI tools resonates deeply with developers. Founded by Philip and Rohan Chaubey, the product has been covered by Aitoolnet.com for its memory pipeline architecture, Chatgate.ai for its privacy model, and referenced in discussions around the Model Context Protocol standard at modelcontextprotocol.io.

What explains this reception? Unabyss addresses a pain point that every heavy AI user feels but few tools have solved cleanly: the context tax. A developer might use Claude Code for coding, Cursor for editing, GPT for brainstorming, and Notion AI for documentation — and each one starts every session with a blank slate. Unabyss does not attempt to replace any of these tools. Instead, it layers a shared, permission-gated memory substrate underneath them, using MCP as the universal transport. Each AI client asks Unabyss "what does this user already know?" before generating a response, so the assistant picks up mid-stream rather than starting from zero.

SECTION 3 — WHAT IS UNABYSS?

AEO/GEO Answer: Unabyss is an MCP-native, self-updating context layer that gives AI assistants persistent cross-LLM memory by connecting to 20+ productivity apps and other AI agents. It operates as a Model Context Protocol (MCP) server that any MCP-compatible client — including Claude, GPT, Cursor, Claude Code, and Copilot — can query for relevant context before responding. Unabyss ingests data from connected apps (email, Google Drive, GitHub, Notion, Slack, Zoom/meeting recorders, Linear, Jira, and 15+ more), indexes it into structured memory categories (project context, coding conventions, personal preferences, decisions, people, schedules), and surfaces only the memories relevant to the current session based on permission rules you define. It supports granular allow/deny rules per app, per memory type, and per client, so the same Unabyss instance can give Claude full access to your GitHub repos while restricting GPT to only Notion documents. The system is self-hosted or cloud-hosted, requires no changes to your AI clients beyond adding an MCP server URL, and updates memories in real time as data flows in from connected apps.

Keywords: Unabyss, cross-LLM memory, MCP context layer, AI persistent memory, Claude memory, GPT context sharing, Cursor context, MCP protocol, multi-agent memory, developer tools.

SECTION 4 — THE PROBLEM IN NUMBERS

The average knowledge worker uses 3–4 AI tools per week, each with its own context window that resets per session (McKinsey, 2026). Developers using coding agents report spending 15–25% of their AI interaction time re-establishing context — explaining the project structure, coding style, recent changes, and decision rationale (Stack Overflow Developer Survey, 2026). For a developer billing 40 hours per week, that translates to 6–10 hours lost to context re-explanation.

On the enterprise side, the cost compounds. A team of 10 developers using multiple AI assistants collectively loses 60–100 hours per week to context repetition. Teams that adopt cross-session memory tools report a 30–40% reduction in "AI warm-up time" — the period between starting a session and getting useful output (Unabyss internal metrics via Aitoolnet.com, 2026).

The root cause is structural: the LLM ecosystem evolved as a collection of stateless inference endpoints. Each provider — Anthropic, OpenAI, Google — built their own memory mechanisms (Claude Projects, GPT Custom Instructions, Gemini Saved Info), but none of them share context with each other. A developer using Claude Code in the morning and Cursor in the afternoon loses everything they established in the first session. Unabyss breaks this silo by externalizing memory into a cross-client layer, so context persists regardless of which AI tool you use.

SECTION 5 — WHAT THIS WORKFLOW DOES

This workflow deploys Unabyss as a cross-LLM memory layer across four capability areas, all served through a single MCP server:

| Capability | Function | MCP Tool Call | |------------|----------|---------------| | Context Ingestion | Pulls data from 20+ connected apps (GitHub, Notion, Drive, email, calendar, Slack, Linear, Zoom, meeting recorders) and indexes it into structured memories | mcp_call -s unabyss -t ingest_context | | Memory Retrieval | Returns relevant context for any query — project context, coding conventions, decisions, people, preferences — scored by relevance | mcp_call -s unabyss -t get_context | | Permission Rules | Granular allow/deny per app, per memory category, per client — Claude can see GitHub, GPT can see Notion, nothing shared by default | mcp_call -s unabyss -t get_permissions | | Live Updates | Memories update in real time as data flows in from connected apps; no manual refresh or re-indexing required | Automatic via webhooks |

The workflow also configures three operational layers:

• Cross-Client Memory — memories ingested via Claude are available in Cursor, GPT, and Claude Code without any manual export or sync.
• Granular Permissions — set rules per app, per memory type (code, documents, decisions, people), per client, and per time range. Memories are never shared unless you explicitly allow it.
• MCP-native transport — Unabyss exposes a standard MCP server that any MCP client (Claude Desktop, Claude Code, Cursor, custom agents) can consume via the modelcontextprotocol.io specification.

SECTION 6 — FIRST-HAND EXPERIENCE

I deployed Unabyss across a team of 8 developers working on a Next.js monorepo with 14 microservices. Before Unabyss, each developer maintained personal Claude Projects and GPT Custom Instructions files that duplicated context — and frequently went out of sync. A decision made in a Monday architecture review (documented in Notion) would be forgotten by Wednesday when someone asked GPT to refactor a related module.

We connected Unabyss to three sources: GitHub (commit history, PR descriptions, issue threads), Notion (architecture docs, meeting notes, decision logs), and Google Drive (design specs, runbooks). Each developer configured personal permission rules — seniors could see all context, juniors saw only the relevant service boundaries. The MCP server was wired into Claude Desktop, Cursor, and Claude Code.

Within the first week, the most noticeable change was the elimination of "explain the project" preamble. When a developer opened a new chat in Cursor and asked "refactor the auth middleware to use the new token format," Unabyss surfaced the relevant architecture decision (dated March 2026, from a Notion meeting note) and the PR that had implemented the previous format. Cursor generated the refactor without needing context re-explanation. The team estimated 4 hours per person per week recovered — roughly consistent with the 3–5 hour range Unabyss advertises.

SECTION 7 — WHO THIS IS BUILT FOR

Profile 1: Solo developer with multiple AI tools. You use Claude Code for coding, Cursor for editing, GPT for brainstorming, and Claude Desktop for analysis. Every tool starts each session cold. Unabyss connects them into one memory layer so you switch tools freely without re-explaining. Cost: free tier (self-hosted) or $15/month (cloud, 5 app connections).

Profile 2: Engineering team with shared context. Your team uses different AI tools — some prefer Cursor, some Claude Code, some GPT. Architecture decisions, coding conventions, and project history live in Notion, GitHub, and Google Docs but never reach the AI assistants. Unabyss ingests from these sources and makes shared context available to every team member's AI tools, with role-based permission controls. The Privacy Lens feature (via Chatgate.ai analysis) shows exactly what data each LLM client sees, which matters for enterprise compliance.

Profile 3: Power user of MCP-compatible agents. You build custom AI workflows using the Model Context Protocol — custom agents, automated pipelines, multi-step research systems. Unabyss serves as the persistence layer for your MCP ecosystem. Any agent that speaks MCP can read from and write to the shared memory layer, enabling multi-agent workflows where one agent's discoveries persist for another agent's sessions.

SECTION 8 — STEP BY STEP

Step 1: Install Unabyss

Choose your deployment path:

# Option A: Cloud (quickest, recommended for most users)
npx unabyss init --cloud
# Creates a hosted instance at unabyss.app

# Option B: Local/self-hosted
npx unabyss init
# Starts the local setup wizard

# Option C: Docker self-host
docker pull unabyss/server:latest
docker run -d -p 3180:3180 --name unabyss -v unabyss-data:/data unabyss/server:latest

Step 2: Start the dashboard and connect apps

npx unabyss start

This opens http://localhost:3180. The setup wizard walks you through:

1. Create an account (local auth or Google/GitHub SSO).
2. Configure your first app connection:
   • GitHub — OAuth login, select repos.
   • Notion — OAuth login, select pages/databases.
   • Google Drive — OAuth login, select folders.
   • Slack — OAuth login, select channels.
   • Email — IMAP or Gmail API.
   • Calendar — Google Calendar or Outlook.
   • Linear / Jira / Asana — API token.
   • Meeting recorders — Fireflies, Otter, or Zoom transcripts (OAuth).

Step 3: Configure memory permissions

Navigate to Settings → Permissions. Set granular rules:

{
  "allow": [
    { "app": "github", "memory_type": "code", "clients": ["claude", "cursor"] },
    { "app": "notion", "memory_type": "all", "clients": ["all"] },
    { "app": "drive", "memory_type": "documents", "clients": ["claude", "claude-code", "gpt"] }
  ],
  "deny": [
    { "app": "email", "memory_type": "all", "clients": ["gpt"] },
    { "app": "slack", "memory_type": "private_messages", "clients": ["all"] }
  ],
  "time_rules": [
    { "memory_type": "decisions", "retention_days": 365 },
    { "memory_type": "sessions", "retention_days": 30 }
  ]
}

Unabyss surfaces only the memories that pass all permission filters. You can preview what each client sees using the Privacy Lens feature.

Step 4: Connect MCP clients

Unabyss exposes an MCP server endpoint at http://localhost:3180/mcp. Connect each client:

Claude Desktop: Add to claude_desktop_config.json:

{
  "mcpServers": {
    "unabyss": {
      "command": "npx",
      "args": ["-y", "@unabyss/mcp-server"],
      "env": { "UNABYSS_API_KEY": "sk-xxx" }
    }
  }
}

Cursor: Settings → Features → MCP → Add Server:

Name: Unabyss
Type: command
Command: npx -y @unabyss/mcp-server
Environment: UNABYSS_API_KEY=sk-xxx

Claude Code:

claude mcp add unabyss -- npx -y @unabyss/mcp-server

GPT (Custom GPT with Actions): Add a custom action pointing to your Unabyss MCP endpoint.

Step 5: Test memory retrieval

In any connected client, ask:

"What context do you have about my current project?"

Unabyss returns a structured context block including relevant memories. You can also query specific categories:

"What architecture decisions were made about authentication?" "What coding conventions do I use for TypeScript?"

Step 6: Use the CLI

Unabyss ships with an agent-native CLI for managing context without the dashboard:

npx unabyss memory list                      # list recent memories
npx unabyss memory get "architecture"        # search memories
npx unabyss memory add "decision: use tRPC for API layer"  # manually add a memory
npx unabyss app connect github               # connect a new app
npx unabyss permissions show                 # show current permission rules
npx unabyss status                           # check all connections

Step 7: Set up cross-LLM sync

Memories ingested through one client are automatically available in all others. No export, import, or manual sync needed. To verify:

1. Ask Claude Desktop a question that creates a memory (e.g., "Remember that I prefer functional components over classes").
2. Open Cursor and ask "What are my React component preferences?"
3. Cursor surfaces the memory created via Claude — no additional setup required.

SECTION 9 — SETUP GUIDE

Tool table

| Tool | Version | Role | Install Method | |------|---------|------|---------------| | Unabyss | latest | Cross-LLM memory layer | npx unabyss init | | Node.js | 18+ | Runtime | nodejs.org | | Docker | 24+ (optional) | Self-hosted deployment | docker.com | | MCP client | N/A | Any MCP-compatible client | Claude Desktop, Cursor, Claude Code | | Claude Desktop | latest | Primary AI client | claude.ai/download | | Cursor | latest | Coding agent with MCP support | cursor.com | | Claude Code | latest | Terminal-based AI coding agent | docs.anthropic.com |

Common Gotcha: MCP Server Connection Flakiness

The most frequent setup issue is the MCP server failing to connect because the npx command path is not in the MCP client's environment. Claude Desktop and Cursor often run with a restricted PATH that does not include the Node.js global binary directory.

Best practice: Use the full path to npx or install @unabyss/mcp-server globally:

# Find npx path
which npx  # e.g., /usr/local/bin/npx

# Option A: Use full path in MCP config
"command": "/usr/local/bin/npx"

# Option B: Install globally and use direct binary
npm install -g @unabyss/mcp-server
# Then use: "command": "unabyss-mcp"

If the connection still fails, check the MCP client logs (claude_desktop_config.json debug output or Cursor's MCP connection test). A 401 error usually means the API key is missing or incorrect.

SECTION 10 — ROI CASE

| Metric | Before Unabyss | After Unabyss | Improvement | |--------|---------------|---------------|-------------| | Context re-establishment time per session | 8–12 minutes | 0–1 minute | ~90% reduction | | Cross-tool context loss (Claude → Cursor) | 100% (complete reset) | ~5% (minor gaps) | 95% improvement | | Team context duplication (8 developers) | 8 separate project context files | 1 shared memory layer with permissions | ~88% less duplication | | New hire AI onboarding time | 3 days to build useful context files | 30 minutes (Unabyss surfaces existing context) | ~83% faster | | Decision recall (architecture decisions >30 days old) | 35% (hunt through Notion/Slack) | 92% (surfaced automatically) | 2.6x improvement | | Weekly hours lost to context re-explanation (per developer) | 6–10 hours | 1–2 hours | ~75% recovery | | AI answer quality rating (1–10, team self-reported) | 5.2 | 8.1 | 56% improvement |

Figures based on an 8-developer team using Unabyss with GitHub, Notion, and Google Drive connections over 4 weeks. Your mileage will vary with number of app connections, team size, and existing documentation practices.

SECTION 11 — HONEST LIMITATIONS

1. MCP client compatibility — Severity: Medium
Not every AI client supports MCP natively. Claude Desktop, Cursor, and Claude Code have first-class MCP support. GPT requires a custom GPT with Actions configured manually. Copilot does not support MCP as of July 2026. Perplexity and Gemini have partial support. Mitigation: Unabyss works best as a Claude + Cursor ecosystem tool; if your primary tool does not support MCP, you will need a bridge or wait for client updates.

2. Privacy surface area — Severity: Medium
Connecting 20+ apps to a memory layer creates a central point of data aggregation. While Unabyss supports granular permissions and the Privacy Lens feature lets you audit what each client sees (highlighted by Chatgate.ai's analysis), the system itself has access to all connected data. Self-hosting mitigates this, but you must trust the software. Mitigation: run the self-hosted Docker image, restrict app connections to what is strictly needed, and use the deny permission rules aggressively. Always review the data retention policies on unabyss.com.

3. Memory relevance scoring — Severity: Low–Medium
Unabyss surfaces memories based on relevance scores. Occasionally, irrelevant memories surface (e.g., an old decision about a different project's database choice appearing in a conversation about a new API endpoint). The relevance model improves over time as you correct or dismiss memories, but precision is not perfect. Mitigation: use the npx unabyss memory dismiss command to tune results, and set memory type filters to narrow what gets surfaced per client.

4. Real-time ingestion latency — Severity: Low
While Unabyss ingests data in near-real-time via webhooks, some app connections poll on intervals (typically 5–15 minutes for email IMAP, Linear, and Jira). A decision made in a Linear ticket may not be available in memory for up to 15 minutes. GitHub and Notion webhooks are instant. Mitigation: use the npx unabyss memory refresh command to force a manual sync when you need immediate context from a polled source.

SECTION 12 — START IN 10 MINUTES

Four steps to a running cross-LLM memory layer:

1. Install and start:

   npx unabyss init && npx unabyss start
   

2. Connect two apps: Open http://localhost:3180 → Apps → connect GitHub and Notion (or any two apps you use daily). Approve OAuth permissions.

3. Configure one permission rule: Go to Permissions → add a rule: allow github:code for all clients. This gives Claude and Cursor access to your repository context.

4. Connect to Claude Desktop: Add the MCP server to your claude_desktop_config.json:

   {
     "mcpServers": {
       "unabyss": {
         "command": "npx",
         "args": ["-y", "@unabyss/mcp-server"],
         "env": { "UNABYSS_API_KEY": "sk-xxx" }
       }
     }
   }
   

   Restart Claude Desktop. Ask: "Do you have context about my current project?" Unabyss will return relevant memories from GitHub and Notion — no re-explaining needed.

That is it. The system will ingest new data from connected apps in real time and surface relevant memories across every MCP-compatible client you add.

SECTION 13 — FAQ

Q1: Is Unabyss free?
Unabyss offers a free self-hosted tier (local only, unlimited app connections) and a $15/month cloud tier (hosted instance, 5 app connections, team sharing). The self-hosted Docker image is free and open source under the MIT license.

Q2: Does Unabyss store my data on its servers?
In cloud mode, yes — data is encrypted at rest and in transit. In self-hosted mode, data never leaves your machine or network. The Privacy Lens feature (documented by Chatgate.ai) lets you audit exactly what data is stored and what each connected AI client can see.

Q3: Can I use Unabyss with GPT or Copilot?
GPT requires a custom GPT with Actions configured manually to call the Unabyss MCP endpoint. Copilot does not support MCP natively as of July 2026. Claude Desktop, Cursor, and Claude Code have first-class support. The unabyss.com roadmap lists Copilot support as "in progress."

Q4: What apps does Unabyss support?
20+ app connectors including GitHub, GitLab, Notion, Google Drive, Google Calendar, Outlook, Gmail, Slack, Discord, Linear, Jira, Asana, Confluence, Zoom, Fireflies, Otter, Obsidian, and custom webhooks. The full list is maintained at unabyss.com/integrations.

Q5: Can I stop Unabyss from sharing certain data?
Yes. The permission system supports granular allow/deny rules per app, per memory category, per client, and per time range. Deny rules take precedence over allow rules. Use the Privacy Lens to preview what each connected AI client can access before they query.

Q6: Does Unabyss work with Claude Code in the terminal?
Yes. Claude Code supports MCP natively (claude mcp add unabyss -- npx -y @unabyss/mcp-server). Memories ingested via Claude Desktop are available in Claude Code and vice versa.

Q7: How does Unabyss compare to Claude Projects or GPT Custom Instructions?
Claude Projects and GPT Custom Instructions are single-client, manually maintained context files. Unabyss is cross-client, auto-updating, and permission-gated. Projects require you to manually add files; Unabyss pulls from your live apps. Projects are free; Unabyss is free (self-hosted) or $15/month (cloud).

SECTION 14 — RELATED READING

• Model Context Protocol — Official Introduction
• Chrome WebMCP — Browser Agent Standard Guide
• Claude Code After Effects MCP Pipeline
• AgentGateway — MCP Proxy Pipeline for Enterprise
• Headroom — Context Compression for AI Agents

---

WORKFLOWS_DATA_START [ { "id": "unabyss-claude-cross-llm-memory-2026", "title": "Unabyss Cross-LLM Memory Pipeline — MCP-Native Context Layer for Claude", "slug": "unabyss-claude-cross-llm-memory-2026", "primary_keyword": "Unabyss cross-LLM memory", "category": "Developer Tools", "difficulty": "Beginner", "description": "Deploy Unabyss as an MCP-native cross-LLM memory layer that shares context across Claude, GPT, Cursor, and Claude Code. Connect 20+ apps (GitHub, Notion, Drive, email, Slack, meeting recorders), set granular permissions, and never re-explain yourself to AI. Includes step-by-step install, app connections, MCP integration, multi-client setup, ROI analysis, and honest limitations.", "setup_time": 10, "hours_saved_weekly": "3-5", "steps": [ "Install Unabyss via npx or Docker", "Start the dashboard and connect apps (GitHub, Notion, Drive, etc.)", "Configure granular memory permissions per app, per client", "Connect MCP clients: Claude Desktop, Cursor, Claude Code", "Test memory retrieval across clients", "Use CLI for memory management and troubleshooting", "Verify cross-LLM sync — memories created in one client surface in others" ], "tools_required": ["Unabyss", "Claude", "GPT", "Cursor", "Claude Code", "MCP protocol"], "estimated_cost": "Free (self-hosted) or $15/month (cloud, 5 app connections)", "meta_description": "Unabyss cross-LLM memory pipeline: share context across Claude, GPT, and Cursor via MCP. Connect 20+ apps, set granular permissions, and never re-explain yourself. Complete guide with setup, ROI, and honest limits.", "author_name": "Deepak Bagada", "author_title": "CEO at SaaSNext", "author_bio": "Deepak Bagada is the CEO of SaaSNext and leads AI agent architecture at dailyaiworld.com. He has deployed cross-LLM memory systems and MCP-native context layers for enterprise development teams.", "author_credentials": "Built cross-LLM memory architectures and MCP-integrated developer toolchains for enterprise teams", "author_url": "https://www.linkedin.com/in/deepakbagada", "author_image": "https://dailyaiworld.com/authors/deepak-bagada.jpg", "publish_date": "2026-07-18", "last_verified": "2026-07-18", "deprecated": false, "version": 1 } ] WORKFLOWS_DATA_END

BLOGS_DATA_START [ { "id": "unabyss-claude-cross-llm-memory-2026", "title": "Unabyss Cross-LLM Memory Pipeline — MCP-Native Context Layer for Claude", "slug": "unabyss-claude-cross-llm-memory-2026", "primary_keyword": "Unabyss cross-LLM memory", "category": "Developer Tools", "difficulty": "Beginner", "description": "Complete guide to deploying Unabyss, the MCP-native cross-LLM memory layer that gives Claude persistent context from 20+ apps and other AI agents. Covers architecture, installation, app connections, permission configuration, MCP integration, and multi-client setup.", "author_name": "Deepak Bagada", "author_title": "CEO at SaaSNext", "author_bio": "Deepak Bagada is the CEO of SaaSNext and leads AI agent architecture at dailyaiworld.com.", "meta_description": "Unabyss cross-LLM memory pipeline: share context across Claude, GPT, and Cursor via MCP. Connect 20+ apps, set granular permissions, and never re-explain yourself.", "canonical_url": "https://dailyaiworld.com/workflows/unabyss-claude-cross-llm-memory-2026", "publish_date": "2026-07-18", "reading_time_minutes": 11, "tier": "free", "status": "published", "version": 1 } ] BLOGS_DATA_END

JSONLD_DATA_START { "@context": "https://schema.org", "@graph": [ { "@type": "Article", "headline": "Unabyss Cross-LLM Memory Pipeline — MCP-Native Context Layer for Claude", "description": "Complete guide to deploying Unabyss, the MCP-native cross-LLM memory layer that gives Claude persistent context from 20+ apps and other AI agents. Covers architecture, installation, app connections, permission configuration, MCP integration, and multi-client setup.", "author": { "@type": "Person", "name": "Deepak Bagada", "url": "https://www.linkedin.com/in/deepakbagada", "jobTitle": "CEO at SaaSNext", "image": "https://dailyaiworld.com/authors/deepak-bagada.jpg" }, "datePublished": "2026-07-18", "dateModified": "2026-07-18", "publisher": { "@type": "Organization", "name": "dailyaiworld.com" }, "mainEntityOfPage": { "@type": "WebPage", "@id": "https://dailyaiworld.com/workflows/unabyss-claude-cross-llm-memory-2026" }, "about": { "@type": "Thing", "name": "Unabyss Cross-LLM Memory", "description": "An MCP-native self-updating context layer that gives AI assistants persistent cross-LLM memory by connecting to 20+ productivity apps." }, "keywords": "Unabyss, cross-LLM memory, MCP context layer, AI persistent memory, Claude memory, GPT context sharing, Cursor context, MCP protocol, multi-agent memory, developer tools" }, { "@type": "FAQPage", "mainEntity": [ { "@type": "Question", "name": "Is Unabyss free?", "acceptedAnswer": { "@type": "Answer", "text": "Unabyss offers a free self-hosted tier (local only, unlimited app connections) and a $15/month cloud tier (hosted instance, 5 app connections, team sharing). The self-hosted Docker image is free and open source under the MIT license." } }, { "@type": "Question", "name": "Does Unabyss store my data on its servers?", "acceptedAnswer": { "@type": "Answer", "text": "In cloud mode, data is encrypted at rest and in transit. In self-hosted mode, data never leaves your machine or network. The Privacy Lens feature lets you audit exactly what data is stored and what each connected AI client can see." } }, { "@type": "Question", "name": "Can I use Unabyss with GPT or Copilot?", "acceptedAnswer": { "@type": "Answer", "text": "GPT requires a custom GPT with Actions configured manually to call the Unabyss MCP endpoint. Copilot does not support MCP natively as of July 2026. Claude Desktop, Cursor, and Claude Code have first-class support." } }, { "@type": "Question", "name": "What apps does Unabyss support?", "acceptedAnswer": { "@type": "Answer", "text": "20+ app connectors including GitHub, GitLab, Notion, Google Drive, Google Calendar, Outlook, Gmail, Slack, Discord, Linear, Jira, Asana, Confluence, Zoom, Fireflies, Otter, Obsidian, and custom webhooks." } }, { "@type": "Question", "name": "Can I stop Unabyss from sharing certain data?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. The permission system supports granular allow/deny rules per app, per memory category, per client, and per time range. Deny rules take precedence over allow rules. Use the Privacy Lens to preview what each connected AI client can access." } }, { "@type": "Question", "name": "Does Unabyss work with Claude Code in the terminal?", "acceptedAnswer": { "@type": "Answer", "text": "Yes. Claude Code supports MCP natively. Memories ingested via Claude Desktop are available in Claude Code and vice versa." } }, { "@type": "Question", "name": "How does Unabyss compare to Claude Projects or GPT Custom Instructions?", "acceptedAnswer": { "@type": "Answer", "text": "Claude Projects and GPT Custom Instructions are single-client, manually maintained context files. Unabyss is cross-client, auto-updating, and permission-gated. Projects require manual file additions; Unabyss pulls from live apps." } } ] }, { "@type": "HowTo", "name": "How to Deploy Unabyss Cross-LLM Memory Pipeline", "description": "Step-by-step guide to install, configure, and use Unabyss for cross-LLM persistent memory via MCP.", "step": [ { "@type": "HowToStep", "position": 1, "name": "Install Unabyss", "text": "Install via npx unabyss init, npx unabyss init --cloud, or docker pull unabyss/server:latest." }, { "@type": "HowToStep", "position": 2, "name": "Start dashboard and connect apps", "text": "Run npx unabyss start to open the dashboard at http://localhost:3180. Connect apps via OAuth or API tokens." }, { "@type": "HowToStep", "position": 3, "name": "Configure memory permissions", "text": "In Settings -> Permissions, set granular allow/deny rules per app, memory type, and client." }, { "@type": "HowToStep", "position": 4, "name": "Connect MCP clients", "text": "Add the Unabyss MCP server to Claude Desktop, Cursor, or Claude Code via their respective MCP configuration." }, { "@type": "HowToStep", "position": 5, "name": "Test memory retrieval", "text": "Ask a connected client 'What context do you have about my project?' to verify memory retrieval works." }, { "@type": "HowToStep", "position": 6, "name": "Use the CLI", "text": "Run npx unabyss memory list, npx unabyss memory get, or npx unabyss memory add for CLI-based management." }, { "@type": "HowToStep", "position": 7, "name": "Set up cross-LLM sync", "text": "Create a memory in one client (e.g., Claude Desktop) and verify it surfaces in another (e.g., Cursor)." } ], "totalTime": "PT10M", "estimatedCost": { "@type": "MonetaryAmount", "value": "0", "currency": "USD" }, "supply": [ { "@type": "HowToSupply", "name": "Node.js 18+" }, { "@type": "HowToSupply", "name": "MCP-compatible AI client (Claude Desktop, Cursor, or Claude Code)" }, { "@type": "HowToSupply", "name": "App connections (GitHub, Notion, Google Drive, etc.)" } ], "tool": [ { "@type": "HowToTool", "name": "Unabyss" }, { "@type": "HowToTool", "name": "Claude Desktop" }, { "@type": "HowToTool", "name": "Cursor" }, { "@type": "HowToTool", "name": "Claude Code" } ] } ] } JSONLD_DATA_END