convez.ai
MCP ServerProdutividadeIntermediário
PIXARTSeu

Synapse — Cérebro Coletivo para IA

PIXARTSeu/Synapse

Memória coletiva permanente, auditada e multi-usuário para workflows com IA

Ver no GitHub
InicialPluginScore · de 0 a 100

Servidor MCP que converte Claude Code e Desktop em assistentes com memória persistente, compartilhada e auditável. Sincroniza conhecimento entre sessões e usuários via 55 ferramentas MCP, 258 skills estruturados e um grafo de memória tipado em SQLite. Deploy auto-hospedado em 2 minutos via Coolify.

Instalação

$npx convez-ai PIXARTSeu/Synapse

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
12
Forks
1
Acompanhando
1
Saúde
37%
Último commit
há 1 mês
Versão
—
Issues abertas
0
Contribuidores
3

Casos de uso

  • Retomar projetos dias depois com contexto completo
  • Compartilhar padrões técnicos entre membros do time
  • Manter histórico de decisões e bugs com audit trail
  • Executar skills reutilizáveis sem reescrever instruções
  • Colaborar em whiteboards estilo FigJam sincronizados

Veredito

Solução robusta e bem arquitetada para o problema real de amnésia de sessão. Adere totalmente ao padrão MCP, oferece auto-hospedagem segura e multi-tenancy. Recomendado para equipes que precisam de continuidade em fluxos de IA; exige infraestrutura (Docker/Coolify).

README

A tradução para o português deste README ainda está na fila.

Your AI assistant forgets everything when you close the session. For your whole team, that's a productivity tax you pay every single day. Synapse fixes it — permanently, collectively, with audit trails.

55 MCP tools, 258 skills, multi-user authentication, 12-page dashboard, collaborative whiteboards, team-safe knowledge graph — served from a single self-hosted server. Claude Code, Claude Desktop, or any MCP client connects and gets the full system.

MCP Tools Skills Multi-User Memory Graph Whiteboards Dual Mode Dashboard Review System Claude Code Claude Desktop Self Hosted License

Built by Daniel De Vecchi · GitHub


2-Minute Setup

Add this to your Claude Code config (~/.claude.json → mcpServers):

"codegraph": {
  "command": "node",
  "args": ["/path/to/skillbrain/packages/codegraph/dist/cli.js", "mcp-proxy"],
  "env": {
    "SKILLBRAIN_MCP_URL": "https://your-server.com/mcp",
    "CODEGRAPH_AUTH_TOKEN": "your-personal-api-key"
  }
}

Restart Claude Code. You now have 50 tools, 258 skills, and shared team memory.

First login creates the admin user automatically. Additional team members are invited from the dashboard (Team page) and each gets their own API key for MCP access.

For Claude Desktop, add the same to ~/Library/Application Support/Claude/claude_desktop_config.json.


See It In Action

Resume a project after days away

> session_resume({ project: "Quickfy" })

## Resume Context: Quickfy

### Last Session
- Date: 2026-04-15
- Task: add stripe payments
- Status: paused
- Summary: Implemented Stripe checkout + webhook handler
- Next steps: Add subscription renewals and account page
- Branch: feat/payments
- Commits: abc123, def456

### Project Memories (3)
- [BugFix conf:3] Cookie forwarding in Server Actions needs explicit headers()
- [Pattern conf:3] Centralize Payload Local API calls in lib/payload.ts

Find the right skill for any task

> skill_route({ task: "add stripe payments" })

Recommended: payments (494 lines), churn-prevention (241), pricing-strategy (232)

> skill_read({ name: "payments" })
→ Full Stripe integration guide: checkout, webhooks, subscriptions, error handling

Share knowledge across the whole team

> memory_query({ scope: "team", type: "BugFix" })

M-bugfix-xxx [BugFix conf:3] @alice • 2026-04-20
  "Every collection in multi-tenant Payload MUST have access control functions..."

M-bugfix-yyy [BugFix conf:2] @bob • 2026-04-22
  "Coolify healthchecks fail on slow migrations — increase start_period to 90s"

A bug Alice fixed last week is now searchable from Bob's session. Personal notes stay private (scope: "personal"), project-specific knowledge scopes to the project, and team learnings are visible to everyone.

Self-service API keys

Each team member rotates their own MCP access token from the Profile page. No shared passwords, no server restart, full audit trail.


What's New — May 2026

  • Whiteboards (FigJam-style, integrated with Synapse data) — full collaborative whiteboard with infinite canvas, sticky notes, frames, shapes, code blocks, free-hand pen, images, emoji stamps, and connectors. The killer feature: drag Synapse memories/skills/sessions/projects directly onto the canvas as live cards, double-click to edit them inline, and run 14 deterministic generators to auto-build boards from your data (by-tag, by-type, by-project, by-skill, by-author, recent, most-used, decisions-log, antipatterns, open-todos, session-timeline, skill-graph, project-overview, semantic-cluster). Includes async collaboration (comments + @mention email + in-app notification inbox + heartbeat presence avatars), 5 templates (Retro, Brainstorm, Kanban, OKR, Mind-map), undo/redo, snap-to-grid + alignment guides, multi-handle resize, group/ungroup, lock, dot voting, timer, color-by-author, markdown sticky, syntax-highlighted code, version snapshots auto-saved hourly, soft-delete trash, pin/favorites, tags + search, read-only public share links, full board export (PNG/JPG/PDF/JSON), MCP exposure (5 new tools), and Figma-style left vertical sidebar. Zero npm dependencies (vanilla JS, ~3000 LOC), MIT-only vendor libs (marked, Prism, html2canvas) self-hosted in /vendor/.
  • Semantic search (vector embeddings) — memory_search now uses hybrid retrieval: 0.5 × BM25 + 0.5 × cosine similarity via Xenova/multilingual-e5-small (384-dim, CPU-only, IT+EN). Memories that share meaning surface even without keyword overlap.
  • Embed-on-add — every new memory is embedded in the background automatically (fire-and-forget, never blocks memory_add). First call downloads the model (~118 MB) to the local cache.
  • Graceful degradation — if the model is unavailable, retrieval falls back to BM25-only. No breaking changes.
  • Backfill script — pnpm backfill:embeddings re-embeds all existing memories in batches of 32 (idempotent, safe to re-run after deploy).

What's New — April 2026

The last wave of releases turned Synapse from a single-user tool into a team platform. Everything below ships in the current build:

  • Multi-user authentication — email + password, admin bootstrap on first login, legacy DASHBOARD_PASSWORD deprecated.
  • Self-service API keys — GET/POST/DELETE /api/me/api-keys from the Profile page, no admin needed for rotation.
  • Memory scopes — personal / team / project on every memory. "My memories" filter isolates what you authored.
  • Team-safe storage layer — ownership tracking (created_by_user_id, updated_by_user_id) across memories, skills and components, with ConcurrencyError on stale writes.
  • Review system & approval queue — memories and skills can be saved as draft and approved from the Review page. Full audit log (review_audit table) with approve/reject/rollback.
  • Skill version history — every upsert snapshots the skill into skill_versions with a change_reason (manual, import, haiku-evolution, rollback). Instant rollback to any prior version.
  • Design system auto-populate — scan Tailwind v4 configs, CSS variables and tokens.json files. Cross-referenced against the component catalog.
  • Component catalog + token linking — bulk import component snippets, auto-detect var(--color-*) references, link to design systems.
  • Project merge & dedup — POST /api/projects-meta/merge absorbs duplicate projects (sessions, memories, env vars, design systems merge with conflict resolution).
  • MemPalace retrieval — BM25 re-ranking on FTS5 trigram candidates (partial/prefix match: "serv" → "server"), closet boost for project-context results, verbatim session chunk indexing with session_search.
  • Memory persistence fix — CodeGraph uploads (codegraph_analyze) now merge only the index tables; memories, sessions, skills and env vars are never overwritten.
  • ENCRYPTION_KEY rotation — POST /api/admin/rotate-key re-encrypts all secrets atomically; safe to run before changing the key in Coolify.
  • CodeGraph auto-upload — proxy auto-uploads the local analysis on connect if the server is stale or missing; Bearer auth fixed for /api/* routes.

Before vs After

Without SynapseWith Synapse
Same bug, 3rd time20 min rediscoveringmemory_search → 2 seconds
New sessionStart from zeroAuto-loads context + top memories
Multiple sessionsIsolated silosOne shared database — instant sync
Resume after days"Where was I?"session_resume → exact state
"Don't do X"Forgotten next sessionAntiPattern with decay — persists
Stale knowledgeOld patterns polluteAuto-decay: unused → deprecated
Which skill to use?Search docs manuallyskill_route → instant match
Team collaborationIsolated inboxes / SlackShared DB, team scope, per-user ownership
Access controlTrust everyonePer-user API keys + audit log
Knowledge curationEverything auto-mergeddraft status + approval queue
Brainstorm / planning meetingMiro/FigJam disconnected from your dataWhiteboard with 14 generators that pull memories/decisions/sessions live
Visual project handoffSlides + 5 stale wikisProject overview board · share read-only link · auto-extract memories from retro

What Is Synapse?

A self-improving AI brain deployed on your server, with multi-user authentication and team-safe storage. Thirteen integrated systems:

📚 1. Skills-as-a-Service (258 skills)

Domain knowledge served via MCP: Next.js, Stripe, SEO, CRO, Payload CMS, Docker, React Native, design systems, and more. Loaded on demand.

skill_list()         → browse all 258 skills
skill_route(task)    → find the best skills for your task
skill_read(name)     → load full skill content
skill_add(name)      → contribute a new skill (draft mode supported)
skill_update(name)   → update a skill, history kept in skill_versions

🧠 2. Memory Graph

Typed knowledge graph with 8 memory types, 5 relationship types, and 3 scopes, stored in SQLite. Retrieval uses hybrid scoring (0.5 × BM25 + 0.5 × cosine similarity) via multilingual-e5-small (384-dim, CPU-only, IT+EN) over FTS5 trigram candidates (partial/prefix match: "serv" → "server"), plus closet boost for project-context relevance. Falls back to BM25-only when the model is unavailable.

Memory types: Fact, Preference, Decision, Pattern, AntiPattern, BugFix, Goal, Todo Edge types: RelatedTo, Updates, Contradicts, CausedBy, PartOf Scopes: personal (private to author), team (visible to everyone), project (scoped to one project)

Every memory has confidence scoring (1–10) with automatic decay. Bad memories fade. Good ones strengthen.

🌐 3. Collective Memory

One shared SQLite database on the server. All clients — Claude Code, Claude Desktop, any MCP client — read and write through the same store. A bug fixed in session A is instantly searchable from session B.

Alice (Claude Code)  ──proxy──→ server ──→ SQLite (shared)
Bob   (Claude Desktop) ──proxy──→ server ──→ SQLite (shared)
Carol (Browser)        ──HTTPS──→ server ──→ Dashboard

👥 4. Multi-User + Teams (NEW)

Email + password authentication with bootstrap admin on first login. Admins invite team members from the Team page, assign roles, and track membership. Every write records the author.

🔑 5. Self-Service API Keys (NEW)

Each user rotates their own MCP access tokens from the Profile page (GET/POST/DELETE /api/me/api-keys). Admin never sees your key. Tokens are hashed at rest.

✅ 6. Review System & Approval Queue (NEW)

Save memories and skills as draft — they land in the Review page queue instead of going live. Admins (or whoever has the review role) approve, reject, or roll back. Every decision is logged in review_audit.

🗂 7. Skill Version History (NEW)

Every time a skill is created or updated, a snapshot goes into skill_versions with a change_reason (manual / import / haiku-evolution / rollback). One click restores any prior version.

🎨 8. Design System Registry (NEW)

Scan Tailwind v4 configs, CSS variables and tokens.json files directly — the MCP accepts the file contents inline. The design system is stored, merged, and cross-referenced with the component catalog.

🧩 9. Component Catalog (NEW)

Register reusable UI components (hero, pricing table, CTA block, etc.) with code snippet, section type, and design-token references auto-detected from var(--color-*) usage. Searchable by project, section, or token.

📁 10. Project Tracking + Work Log + Merge

Projects are auto-derived from sessions. Every session records task, status, deliverables, next steps, branch, and commits. Duplicates can be merged without losing history.

project_list()                → all projects with status
project_merge({ from, into }) → absorb a duplicate project
session_resume({ project })   → full context to continue work

📊 11. Hub Dashboard

Web dashboard served on the same port as the MCP HTTP server. Bearer-token auth shared with MCP. Twelve pages:

  • Home — stats, recent memories, sessions
  • Projects — all projects with status and context
  • Work Log — deliverables timeline per project
  • Skills — browse/search 258 skills, edit & version
  • Memories — explore memories with scope / type / project / author filters
  • Sessions — timeline of all sessions across the team
  • Whiteboards — list, search, pin, tag, multi-select, trash + restore
  • Components — component catalog with design-token linking
  • Design Systems — scan, merge and inspect design tokens
  • Team — invite users, assign roles, manage members
  • Review — approval queue for draft memories and skills
  • Profile — rotate your API keys, change password

⚡ 12. Auto-Session Tracking

The proxy auto-detects your project (from package.json or folder name), git branch, and client type (Code vs Desktop). Sessions are created, heart-beated and closed automatically.

🎨 13. Whiteboards (NEW — May 2026)

A FigJam-style infinite canvas, but wired to your Synapse data. Drag any memory / skill / session / project onto the board as a live card and edit it in place. Run 14 generators to auto-build boards from your knowledge graph (by tag, by type, by project, by skill, by author, recent, most-used, decisions log, antipatterns, open todos, session timeline, skill graph, project overview, semantic cluster via K-means + embeddings). Sticky notes with markdown, code blocks with syntax highlighting, frames, free-hand pen, shapes (rect/ellipse/triangle), images (drag-drop, base64 inline), emoji stamps, connectors with 4 kinds (related/depends-on/blocks/leads-to). Full async collaboration: comments threading, @email mentions (email + in-app inbox), heartbeat-based presence avatars, dot voting, timer, color-by-author. 5 templates (Retro, Brainstorm 3-step, Kanban, OKR, Mind-map). Auto-snapshots hourly, soft-delete trash + restore, pin/favorites, tags, search across boards, read-only public share links, export PNG/JPG/PDF/JSON. Zero JS dependencies (vanilla, ~3000 LOC); only 3 MIT vendor libs self-hosted (marked, Prism, html2canvas).

whiteboard_list({ scope, projectName, tag, pinned, search }) → boards
whiteboard_create({ name, scope, nodes, tags, description })  → new board
whiteboard_add_nodes({ id, nodes, connectors })               → append
whiteboard_read({ id })                                        → full state
whiteboard_search({ q })                                       → matches

Dashboard preview


55 MCP Tools

Memory (8)

ToolPurpose
memory_addSave a memory (auto-detects contradictions, supports scope and draft)
memory_searchHybrid search (BM25 + vector cosine) across all memory fields
memory_queryFilter by type, project, scope, author, skill, confidence
memory_loadLoad top-scored memories for current session
memory_add_edgeCreate relationships between memories
memory_statsStatistics, contradictions and active drafts
memory_decayApply decay cycle (reinforce / decay / deprecate)
memory_suggestAI-suggested memories to promote or merge

Skills (11)

ToolPurpose
skill_listList all skills with filters
skill_readRead full skill content
skill_routeFind best skills for a task
skill_statsSkills statistics by type / category
skill_addCreate a new skill (draft mode supported)
skill_updateUpdate a skill (versioned automatically)
agent_listList all registered agents
agent_readRead agent prompt
command_listList all slash commands
command_readRead command content
cortex_briefing5-layer working memory briefing

Sessions (6)

ToolPurpose
session_startLog session with project + task
session_heartbeatKeep long-running sessions alive
session_endClose with deliverables + next steps
session_resumeFull context to continue a project
session_historyRecent sessions, filter by project or author
session_searchFull-text search across verbatim past session content

Projects (10)

ToolPurpose
project_listAll projects with status and context
project_list_fullFull project export including env, stack, CI/CD
project_getRead a single project by slug
project_scanDetect stack, CMS, deploy target from repo
project_updateUpdate project metadata
project_mergeMerge a duplicate project into another
project_set_envEncrypt & store a single env var
project_set_env_batchEncrypt & store multiple env vars
project_get_envRead decrypted env vars for an authorised user
project_generate_env_exampleEmit a redacted .env.example

Code Intelligence (7)

ToolPurpose
codegraph_querySemantic search by concept
codegraph_context360-degree view of a symbol
codegraph_impactBlast radius before editing
codegraph_detect_changesMap git diff to affected symbols
codegraph_renameGraph-aware multi-file rename
codegraph_list_reposAll indexed repositories
codegraph_cypherRaw SQL against the graph

Components & Design Systems (8)

ToolPurpose
component_addRegister a component with code snippet + tokens
component_listList all components with filters
component_getGet a single component
component_searchFull-text search across components
component_scanBulk import from file contents
design_system_scanParse Tailwind config / CSS vars / tokens.json
design_system_getRead the design system for a project
design_system_setOverwrite the design system manually

Whiteboards (5) (NEW)

ToolPurpose
whiteboard_listList boards with filters (scope, project, tag, pinned, search)
whiteboard_readRead a board (metadata + nodes + connectors)
whiteboard_createCreate a new board (with optional seed nodes/tags/description)
whiteboard_add_nodesAppend nodes/connectors to an existing board
whiteboard_searchFull-text search across all boards

Architecture

flowchart TB
    subgraph Clients["Clients"]
        CC[Claude Code]
        CD[Claude Desktop]
        AM[Any MCP Client<br/>Cursor · Windsurf · OpenCode]
    end

    Proxy["proxy.ts<br/><sub>auto-session · auto-project · auto-branch</sub>"]

    subgraph Server["your-server.com · Coolify / Docker"]
        Auth["🔐 Auth layer<br/>email+password · API keys · roles"]
        Tools["🛠 55 MCP tools<br/>memory · skills · sessions · projects · codegraph · components · whiteboards"]
        Review["📝 Review / approval queue"]
        Hub["📊 Hub Dashboard · 12 pages"]
        Whiteboards["🎨 Whiteboards<br/><sub>FigJam-style · 14 generators · share links</sub>"]
    end

    subgraph Storage["SQLite · single source of truth"]
        Skills["📚 258 skills<br/><sub>FTS5 · versioned</sub>"]
        Memory["🧠 Memory Graph<br/><sub>8 types · 5 edges · 3 scopes</sub>"]
        Projects["📁 Projects + Work Log + Merge"]
        Components["🧩 Components + Design Systems"]
        Boards["🖼 Whiteboards<br/><sub>state · snapshots · activity · presence</sub>"]
        Audit["🧾 Audit log<br/><sub>review_audit · skill_versions</sub>"]
        Migrations["⚙️ 27 migrations · 000 → 026"]
    end

    CC -- stdio --> Proxy
    CD -- stdio --> Proxy
    AM -- stdio --> Proxy
    Proxy -- "HTTPS + Bearer (per-user API key)" --> Auth
    Auth --> Tools
    Auth --> Hub
    Auth --> Whiteboards
    Tools --> Review
    Tools --> Skills
    Tools --> Memory
    Tools --> Projects
    Tools --> Components
    Tools --> Boards
    Review --> Audit
    Hub --> Skills
    Hub --> Memory
    Hub --> Projects
    Hub --> Components
    Hub --> Boards
    Hub --> Audit
    Whiteboards --> Boards
    Whiteboards --> Memory

    classDef server fill:#0f172a,stroke:#334155,color:#f1f5f9
    classDef store fill:#1e1b4b,stroke:#4338ca,color:#e0e7ff
    classDef client fill:#064e3b,stroke:#10b981,color:#d1fae5
    class Server server
    class Storage store
    class Clients client

Self-Hosted Setup

Option A: Connect to an existing server (2 minutes)

Get an API key from your admin (or generate one from your Profile page), then add the MCP config as shown in 2-Minute Setup.

Option B: Deploy your own server

1. Clone and build

git clone https://github.com/deve1993/skillbrain
cd skillbrain/packages/codegraph
npm install && npm run build

2. Import skills

node dist/cli.js import-skills ../..

3. Run locally

# Local MCP (stdio — single machine, no auth)
node dist/cli.js mcp

# HTTP server (for remote access + dashboard + multi-user)
node dist/cli.js mcp --http --port 3737

4. Bootstrap the admin user

On first HTTP start, set ADMIN_EMAIL and DASHBOARD_PASSWORD to bootstrap the admin account. After first login these become optional — the admin manages users from the dashboard.

DASHBOARD_PASSWORD is kept for backwards compatibility (migration 012_deprecate_dashboard_password.sql), but the preferred auth path is per-user email + password + API keys.

5. Deploy on Coolify / Docker

docker build -t skillbrain .
docker run -p 3737:3737 \
  -v skillbrain-data:/data \
  -e ADMIN_EMAIL=you@team.com \
  -e DASHBOARD_PASSWORD=bootstrap-only-password \
  skillbrain

On Coolify: point to packages/codegraph/Dockerfile, set env vars, add persistent volume at /data.

6. Configure clients

Each team member gets their own API key from the dashboard and configures:

"codegraph": {
  "command": "node",
  "args": ["/path/to/dist/cli.js", "mcp-proxy"],
  "env": {
    "SKILLBRAIN_MCP_URL": "https://your-server.com/mcp",
    "CODEGRAPH_AUTH_TOKEN": "user-specific-api-key"
  }
}

How It Compares

FeatureCLAUDE.mdMem0 / ZepSpacebotSynapse
MemoryManual textVector DBTyped graph (Rust)Typed graph (SQLite + MCP)
RetrievalNoneCosine similarityKeywordBM25 + vector embeddings + trigram FTS5 + closet boost
Cross-sessionNoAPI callsChat channelsShared SQLite via proxy
Memory typesNoneKey-value8 types8 types + 5 edge types + 3 scopes
Contradiction detectionNoNoNoAuto on save
Confidence decayNoNoNoAutomatic
SkillsNoNoGeneric258 domain skills
Project trackingNoNoNoAuto-derived + work log + merge
Code intelligenceNoNoNoAST + impact + call graph
DashboardNoCloud UINo11-page self-hosted hub
Multi-userNoNoPer-workspaceEmail+password + per-user API keys
Approval workflowNoNoNoDraft → review queue + audit
Skill versioningNoNoNoFull history + rollback
Setup0 minAPI keyCargo build2 min (MCP config)
Works withClaude CodeAny LLMDiscord/SlackAny MCP client

Skill Catalog (258 total)

CategoryCountExamples
Process109brainstorming, debugging, TDD, planning, review
Other (domain)34specialists, tooling, integrations
Commands23/frontend, /audit, /new-project, /clone
Agents20planner, builder, ux-designer, seo-specialist
Marketing15CRO, copywriting, pricing, launch strategy
SEO14audit, technical, content, schema, geo, hreflang
Frontend9nextjs, tailwind, shadcn, i18n, animations
Backend7trpc, auth, forms, database, payments
Lifecycle5codegraph-context, capture-learning, post-session-review
CMS3payload, cms, mongodb
Files3file-handling, pdf, csv
Infrastructure3ci-cd, coolify, docker
Legal3gdpr, iubenda, legal-templates
Monitoring2monitoring-nextjs, monitoring-expert
Performance2performance, web-vitals
Realtime2realtime, websocket-engineer
Automation · Security · System · Video1 eachn8n, security-headers, system-sync, video-producer

FAQ

Q: Does this work with Cursor / Windsurf / OpenCode? A: Yes — any tool that supports MCP over stdio, through the included HTTP proxy.

Q: Can I have multiple users with different permissions? A: Yes. Email + password login, admin / user roles, per-user API keys, and every write records the author.

Q: Can I review memories and skills before they go live? A: Yes. Save them as draft — they land in the Review page queue. Approvals, rejections and rollbacks are logged in review_audit.

Q: What happens to memories created by someone who leaves the team? A: Ownership is tracked (created_by_user_id). Admins can list and re-assign.

Q: How do I migrate from v1 (shared DASHBOARD_PASSWORD) to v2 (multi-user)? A: Set ADMIN_EMAIL before first login — the current DASHBOARD_PASSWORD bootstraps the admin account. Generate API keys per team member from the Team page. The old shared password keeps working as a fallback until you remove it.

Q: What happens offline? A: The proxy needs internet to reach the server. For offline use, run node cli.js mcp directly — local SQLite, no server, no multi-user.

Q: How does it get smarter over time? A: Every session captures memories (bugs, patterns, decisions). Confidence grows with validation, decays without use. Draft memories sit in the review queue until approved. Skills auto-evolve when Haiku proposes updates that an admin approves.

Q: What inspired this? A: Spacebot.sh by Spacedrive — their typed memory system with graph edges. We adapted it for MCP + SQLite + self-hosted deployment, and extended it with multi-user auth, approval workflow and skill versioning.


Contributing

Contributions welcome:

  • New domain skills (submit as draft — admin will review)
  • Memory Graph integrations
  • Dashboard improvements
  • Multi-language support
  • Migration scripts between Synapse instances

License

Synapse is dual-licensed:

  • AGPL-3.0 — Free for open source use. If you run a modified version over a network (including SaaS), you must share your source code under AGPL-3.0.
  • Commercial License — For proprietary/closed-source deployments. Removes all AGPL obligations.

The complete AGPL-3.0 text is in the LICENSE file.

Need a commercial license? Contact daniel@pixarts.eu.


Built with Claude Code + Synapse collective memory

Ver o original no GitHub

Bom para

Relacionados