# SYNAPSE-DOKUMENTATION — Fullständig referens
# Genererad: 2026-07-18T05:59:24.403Z
# Totalt antal artiklar: 47
Detta dokument innehåller den fullständiga Synapse API-dokumentationen.
Base URL: https://synapse.schaefer.zone
Language: sv
========================================================================
## KATEGORI: KOM IGÅNG
Allt du behöver för att komma igång med Synapse.
────────────────────────────────────────────────────────────
# Autentisering & Mind Keys
SUMMARY: Hur Synapse-autentisering fungerar: Mind Keys för agenter, JWT:er för människor, ?key= för URL-endast-verktyg.
KEY CONTEXT:
Two auth methods: Mind Key (token-scoped, never expires) and JWT (user-scoped, 7-day expiry).
Mind Key: Authorization: Bearer mk_xxx OR ?key=mk_xxx (60 req/min limit on query)
JWT: Authorization: Bearer eyJ... (no rate limit, used for /register, /login, /minds, /sharing)
Mind Key is shown only once at creation. Store it permanently.
Each mind has exactly one Mind Key. Multiple minds = multiple keys.
Autentisering & Mind Keys
Synapse använder två autentiseringsmetoder, var och en optimerad för olika
användningsområden. Att förstå skillnaden är väsentligt för att bygga pålitliga
integrationer.
Två autentiseringsmetoder
| Metod | Användningsområde | Hastighetsgräns | Utgång |
|--------|----------|------------|--------|
| Mind Key | LLM-agenter, automatiserade verktyg | Ingen (header) / 60 min (query) | Aldrig |
| JWT | Mänskligt gränssnitt, kontoåtgärder | Ingen | 7 dagar |
Mind Key (för agenter)
En Mind Key är en klientomfattande API-token. Den autentiserar en enskild minds
data (minnen, uppgifter, chatt, skript etc.). Använd den för:
- LLM-agenter som anropar API:et
- Bakgrundsautomationsskript
- MCP-serverkonfiguration
- Alla långlivade integrationer
Header-autentisering (rekommenderas)
[CODE BLOCK]
Queryparameter (för URL-endast-verktyg)
[CODE BLOCK]
> [!WARNING]
> Queryparametern är begränsad till 60 begäranden per minut.
> Bearer-headern har ingen hastighetsgräns. Använd headern när er klient
> stöder egna headers.
Skapa en Mind Key
[CODE BLOCK]
Svaret inkluderar — spara den omedelbart, den visas endast en gång.
Lista era minds
[CODE BLOCK]
Ta bort en mind (oåterkalleligt!)
[CODE BLOCK]
JWT (för människor)
JWT:er autentiserar användarkontot, inte en specifik mind. Använd dem för:
- Kontoregistrering och inloggning
- Skapa / lista / ta bort minds
- Dela minds med andra användare
- Hantering av Web Push-prenumerationer
Registrera
[CODE BLOCK]
Returnerar:
Logga in
[CODE BLOCK]
Returnerar:
JWT-utgång
JWT:er löper ut efter 7 dagar. När en JWT löper ut, anropa igen för
att få en ny. Mind Key löper aldrig ut, så befintliga agentintegrationer
fortsätter fungera.
Säkerhetsbästa praxis
> [!CRITICAL]
> - Lägg aldrig Mind Keys i git. Använd miljövariabler.
> - Logga aldrig Mind Keys. Maskera dem i loggar ().
> - Rotera nycklar om ni misstänker läcka (ta bort mind, skapa en ny).
> - Använd en mind per projekt för att begränsa skadeomfånget om en nyckel läcker.
Mönster med miljövariabel
[CODE BLOCK]
[CODE BLOCK]
MCP-serverkonfiguration
[CODE BLOCK]
Flera-mind-mönster
Varje användare kan ha flera minds. Vanliga mönster:
| Mind-namn | Syfte |
|-----------|---------|
| | Jobbrelaterade minnen |
| | Personliga inställningar, familj |
| | Specifik projektkontext |
| | Inlärningsframsteg |
| | Allmän reserv |
Använd olika Mind Keys för olika LLM-sessioner för att hålla kontexter isolerade.
Hastighetsgränser
| Autentiseringsmetod | Gräns | Omfattning |
|-------------|-------|-------|
| Mind Key (header) | Ingen | Per-mind |
| Mind Key (?key=) | 60/min | Per-IP |
| JWT (header) | Ingen | Per-användare |
| Publika endpoints | Ingen | Global |
Headers för hastighetsgräns (, ,
) inkluderas i svar när tillämpligt.
Nästa steg
- Mind Key vs JWT — när man ska använda vilken
- Memory API — vad ni kan göra med en Mind Key
- User API — kontohantering med JWT:er
────────────────────────────────────────────────────────────
# Mind Key vs JWT — vad när?
SUMMARY: Beslutsguide: Mind Key för agentdataåtkomst, JWT för kontohantering.
KEY CONTEXT:
Mind Key: tenant-scoped, never expires, for memory/chat/tasks/scripts/computers/webhooks.
JWT: user-scoped, 7-day expiry, for /register, /login, /minds (CRUD), /sharing, /push.
Simple rule: if it touches a single mind's data → Mind Key. If it manages the account → JWT.
Exception: /computers/me/* uses Computer Token (not Mind Key or JWT).
Mind Key vs JWT — vad när?
Synapse har två autentiseringstoken. Att välja fel leder till 401-fel. Den här
guiden ger er ett tydligt beslutsramverk.
Snabb beslutstabell
| Ni vill... | Använd |
|----------------|-----|
| Lagra / återkalla minnen | Mind Key |
| Skicka / polla chattmeddelanden | Mind Key |
| Hantera uppgifter | Mind Key |
| Lagra skript | Mind Key |
| Registrera webhooks | Mind Key |
| Styr datorer | Mind Key (användarsida) / Computer Token (agentsida) |
| Registrera användarkonto | Inget (publik) |
| Logga in | Inget (publik) |
| Skapa / lista / ta bort minds | JWT |
| Dela en mind med en annan användare | JWT |
| Prenumerera på web push-aviseringar | JWT |
| Visa granskningslogg | Mind Key |
Den enkla regeln
> [!TIP]
> Om det rör en enskild minds data → Mind Key.
> Om det hanterar kontot eller mind-metadata → JWT.
Mind Key — dataåtkomsttoken
En Mind Key ger åtkomst till en minds data. Det är en långlivad token som
aldrig löper ut (tills minden tas bort). Perfekt för:
- LLM-agenter som persistens minnen mellan sessioner
- Bakgrunds-cron-jobb
- MCP-serverkonfiguration
- Webhook-integrationer
- Mobilappar som läser minne
Vad Mind Key kan göra
- — läsa alla minnen i denna mind
- — lagra/uppdatera minnen
- — läsa chattmeddelanden
- — skicka chattmeddelanden
- — lista uppgifter
- — skapa uppgifter
- — lagra skript
- — registrera webhooks
- — köa datorkommandon
Vad Mind Key INTE kan göra
- Skapa / lista / ta bort minds (behöver JWT)
- Dela mind med annan användare (behöver JWT)
- Visa användarkontoinfo (behöver JWT)
- Prenumerera på web push (behöver JWT)
JWT — token för kontohantering
En JWT autentiserar användarkontot. Den löper ut efter 7 dagar och används
för kontooperationer som spänner över flera minds eller involverar andra
användare.
Vad JWT kan göra
- — skapa en ny mind (returnerar en ny Mind Key)
- — lista alla minds för denna användare
- — ta bort en mind
- — dela en mind med en annan användare
- — prenumerera på web push-aviseringar
- — lista mind-delningar
Vad JWT INTE kan göra
- Läsa / skriva minnen (behöver Mind Key)
- Skicka chattmeddelanden (behöver Mind Key)
- Hantera uppgifter (behöver Mind Key)
- Registrera webhooks (behöver Mind Key)
Specialfall: Computer Token
-endpoints (agentriktade, för screen-remote-agent) använder en
tredje tokentyp: Computer Token. Denna token returneras av
när en installationskod löses in och är specifik för
en registrerad dator.
| Endpoint | Autentisering |
|----------|------|
| | Computer Token |
| | Computer Token |
| | Mind Key eller JWT |
| | Mind Key eller JWT |
Vanliga mönster
Mönster 1: Enskild LLM-agent
1. Registrera en gång → få JWT
2. Skapa en mind → få Mind Key
3. LLM använder Mind Key för allt
Mönster 2: Flerprojektsagent
1. Registrera en gång → få JWT
2. Skapa flera minds (work, personal, project-x) → få flera Mind Keys
3. LLM laddar olika Mind Key baserat på kontext
Mönster 3: Team-delning
1. Användare A skapar en mind → får Mind Key A
2. Användare A delar med Användare B via JWT ()
3. Användare B kan nu komma åt via sin egen JWT
4. För LLM-åtkomst måste Användare B skapa sin egen Mind Key (eller använda A:s)
Mönster 4: MCP-server
MCP-servrar använder alltid Mind Key (satt via -miljövariabel).
En MCP-serverinstans = en mind. För multi-mind-åtkomst, kör flera MCP-instanser
eller implementera klientbaserad mind-växling.
Fusklapp för tokenformat
| Token | Format | Exempel |
|-------|--------|---------|
| Mind Key | + 36 tecken | |
| JWT | + base64 | |
| Computer Token | + 36 tecken | |
Nästa steg
- Autentisering — fullständig auth-guide
- User & Minds API — JWT-skyddade endpoints
- Memory API — Mind Key-skyddade endpoints
────────────────────────────────────────────────────────────
# Snabbstart för LLM-agenter
SUMMARY: I 3 API-anrop: återkalla alla minnen, lagra ett nytt, sök. Det väsentliga LLM-arbetsflödet.
KEY CONTEXT:
Base URL: https://synapse.schaefer.zone
Auth: Authorization: Bearer YOUR_MIND_KEY (header) OR ?key=YOUR_MIND_KEY (query)
ALWAYS call /memory/recall at the start of every session.
Wichtigste Befehle: GET /memory/recall, POST /memory, GET /memory/search?q=...
Categories: identity, preference, fact, project, skill, mistake, context, note, credentials
Priorities: low, normal, high, critical
FTS5 search: multiple words = AND, "phrases" in quotes, prefix* for prefix search
Snabbstart för LLM-agenter
Ni förlorar allt minne mellan sessioner. Synapse er er externa hjärna. Den här
guiden visar de tre väsentliga API-anropen som varje LLM-agent måste känna till.
> [!CRITICAL]
> Anropa i BÖRJAN av VARJE session.
> Utan detta anrop har ni inget minne av vem användaren är, vad ni har lovat
> eller vad ni arbetade med senast.
Steg 1: Återkalla alla minnen (ALLTID FÖRST)
[CODE BLOCK]
Returnerar en strukturerad oformaterad textsammanfattning av alla lagrade minnen.
Tolka denna för att återuppbygga er mentala modell av användaren, deras projekt
och tidigare interaktioner.
Exempel på svar:
[CODE BLOCK]
Steg 2: Lagra ett nytt minne
När ni lär er något värt att komma ihåg:
[CODE BLOCK]
Kategorier: , , , , , , , ,
Prioriteringar: , , ,
> [!TIP]
> Inkludera alltid ett -fält — en kort identifierare för minnet. Detta låter
> er uppdatera samma minne senare genom att POSTa igen med samma nyckel.
Steg 3: Sök efter ett specifikt minne
[CODE BLOCK]
> [!TIP]
> FTS5-syntax: flera ord = AND-sökning. Fraser i citattecken: .
> Prefixsökning: . Boolesk: .
Öppna verktyg (inga auth-headers)
Om ert verktyg bara kan öppna URL:er (inga egna headers), använd -parametern:
[CODE BLOCK]
> [!WARNING]
> är begränsad till 60 begäranden/minut. Bearer-headern har ingen
> hastighetsgräns. Använd Bearer-headern när det är möjligt.
Komplett sessionsarbetsflöde
1. Sessionsstart: — ladda alla minnen
2. Under arbete: — hitta specifika fakta
3. Vid ny info: — lagra den (med kategori, nyckel, taggar, prioritet)
4. Periodvis: — kontrollera efter mänskliga meddelanden
5. Sessionsavslut: Lagra alla slutgiltiga lärdomar via
Vanliga mönster
Uppdatera ett befintligt minne
POST med samma och — det befintliga minnet uppdateras,
inte dupliceras.
Lagra en projektstatus
[CODE BLOCK]
Registrera ett misstag (så att ni inte upprepar det)
[CODE BLOCK]
Kontrollera efter mänskliga meddelanden
[CODE BLOCK]
Returnerar olästa meddelanden från människan. Svara med:
[CODE BLOCK]
Nästa steg
- Autentisering — Mind Key vs JWT
- Memory API-referens — alla 22 minnes-endpoints
- Chat API — asynkron kommunikation med människor
- LLM-kokbok — praktiska mönster
────────────────────────────────────────────────────────────
# Snabbstart (människa)
SUMMARY: Registrera ett konto, skapa din första mind, lagra ett minne — allt på 5 minuter.
Snabbstart (människa)
Den här guiden går igenom hur ni skaffar ett Synapse-konto, er första Mind Key
och lagrar ert första minne. Total tid: 5 minuter.
Steg 1: Registrera ett konto
Öppna Synapse API och skapa ett konto:
[CODE BLOCK]
Svar:
[CODE BLOCK]
> [!TIP]
> Spara JWT:en på en säker plats — ni behöver den för att skapa minds. JWT:en
> löper ut efter 7 dagar; logga in igen med samma endpoint för att förnya.
Steg 2: Skapa er första mind
En "mind" är en isolerad minnesomfattning. De flesta användare börjar med en
mind, men ni kan ha flera (t.ex. "work", "personal", "project-x"). Varje mind
har sin egen unika Mind Key.
[CODE BLOCK]
Svar:
[CODE BLOCK]
> [!CRITICAL]
> Spara omedelbart. Den visas endast en gång och kan inte
> hämtas senare. Om ni tappar den måste ni skapa en ny mind.
Steg 3: Lagra ert första minne
Använd nu Mind Key för att lagra ett minne:
[CODE BLOCK]
Svar:
[CODE BLOCK]
Steg 4: Återkalla alla minnen
För att hämta allt ni har lagrat:
[CODE BLOCK]
Svar (oformaterad text, optimerad för LLM-konsumtion):
[CODE BLOCK]
Steg 5: Sök bland minnen
Hitta specifika minnen via nyckelord:
[CODE BLOCK]
Steg 6: Anslut er LLM
Det enklaste sättet att ge er LLM åtkomst till Synapse är via MCP:
- Claude Desktop-konfiguration — 2 minuters konfiguration
- Claude Code-konfiguration — terminalintegration
- Cursor-konfiguration — IDE-integration
Efter konfiguration kommer er LLM automatiskt att anropa i början
av varje session och persistens nya fakta via .
Minneskategorier
Synapse stöder 8 kategorier — välj den mest specifika:
| Kategori | Användningsområde |
|----------|----------|
| | Användarnamn, roll, kontaktinfo |
| | Tycker om, ogillar, arbetsstil |
| | Verifierbara fakta (projektdetaljer, datum) |
| | Projektstatus, milstolpar, uppgifter |
| | Saker användaren är bra på |
| | Tidigare fel — undvik att upprepa |
| | Sessionsrelevant kontext |
| | Diverse anteckningar |
Prioriteringsnivåer
- — bra att veta
- — standard
- — viktig
- — får aldrig glömmas (användaridentitet, juridisk info)
Nästa steg
- Fördjupning i autentisering
- Mind Key vs JWT
- Memory API-referens
- MCP-integration
────────────────────────────────────────────────────────────
# Vad är Synapse?
SUMMARY: Synapse är ett beständigt minnes-API för LLM-agenter — er AI glömmer aldrig mellan sessioner.
KEY CONTEXT:
Synapse is an HTTP API that gives LLM agents persistent memory across sessions.
Base URL: https://synapse.schaefer.zone
Auth: Authorization: Bearer YOUR_MIND_KEY (header) OR ?key=YOUR_MIND_KEY (query, rate-limited 60/min)
Most important endpoints: GET /memory/recall (start of every session), POST /memory (store new facts), GET /memory/search?q=...
Mind Key = tenant-scoped API key. Each user can have multiple minds (projects/contexts).
MCP server available: npx -y synapse-mcp-api (79 tools for Claude Desktop, Cursor, etc.)
Vad är Synapse?
Synapse är ett beständigt minnes-API för LLM-agenter. Det löser det
fundamentala problemet med varje chattbaserad LLM: mellan sessioner glömmer
agenten allt. Synapse ger er AI en permanent, sökbar hjärna som överlever över
konversationer, över dagar och över olika LLM-leverantörer.
> [!CRITICAL]
> Om ni är en LLM-agent som läser detta: anropa i början
> av varje session. Utan detta anrop har ni inget minne av tidigare
> interaktioner, ingen kunskap om vem användaren är och ingen kontext om
> pågående projekt.
Problemet Synapse löser
Varje modern LLM (Claude, GPT, Gemini, Llama) har samma arkitektoniska
begränsning: konversationens kontextfönster är ändligt, och när sessionen slutar
är allt tillstånd förlorat. Detta innebär att er AI-assistent:
- Glömmer ert namn, era inställningar och pågående projekt mellan chattar
- Inte kan lära sig av tidigare misstag över sessioner
- Saknar kontinuitet för långvarigt arbete
- Ställer samma förtydligande frågor varje gång
Synapse fixar detta genom att tillhandahålla ett enkelt HTTP-API där LLM:en kan
lagra och hämta strukturerade minnen. Minnena persistens på servern, indexerade
och sökbara, så varje framtida session kan återkalla dem.
Nyckelfunktioner
- Beständig minneslagring — fakta, inställningar, projekt, misstag, färdigheter
- Fulltextssökning (FTS5) — hitta vilket minne som helst via nyckelord på millisekunder
- Semantisk sökning — inbäddningsbaserad likhetssökning för begreppsliga frågor
- Multitenant — varje användare har isolerade "minds" (en användare, många projekt)
- Asynkron chatt — människor kan lämna meddelanden till agenten medan den arbetar
- Uppgifter & schemaläggning — inbyggd uppgiftshanterare och cron-schemaläggare
- MCP-integration — 79 verktyg exponerade som Model Context Protocol för Claude, Cursor, Continue
- Webbläsar- & datorstyrning — fjärrstyrningsverktyg för automation
- Webhooks — få HTTP-återanrop vid minnes-/chatt-/uppgiftsändringar
Hur det fungerar
[CODE BLOCK]
1. LLM:en anropar vid sessionsstart
2. Synapse returnerar en strukturerad textsammanfattning av alla lagrade minnen
3. LLM:en arbetar och anropar periodvis för att lagra nya fakta
4. När användaren ställer en fråga kan LLM:en anropa
5. Vid sessionsavslut persistens viktig ny kontext för nästa session
Vem är det för?
- LLM-agentutvecklare som behöver beständigt tillstånd
- Avancerade användare som kör lokala LLM:er (Ollama, LM Studio) med egna agenter
- Team som bygger AI-assistenter som behöver delat minne
- Automationsingenjörer som kedjar LLM-anrop över sessioner
Snabb jämförelse
| Funktion | ChatGPT Memory | Synapse |
|---------|---------------|---------|
| Lagringsplats | OpenAI-servrar | Din server |
| API-åtkomst | Nej (sluten) | Ja (REST + MCP) |
| Multitenant | Nej | Ja (minds) |
| Anpassade kategorier | Nej | Ja (8 kategorier) |
| Sökning | Begränsad | FTS5 + semantisk |
| Självhostbart | Nej | Ja (Docker) |
Nästa steg
- Snabbstart för människor — skaffa en Mind Key på 5 minuter
- Snabbstart för LLM:er — första API-anrop
- Autentisering — Mind Keys vs JWT:er
- Arkitekturöversikt — hur Synapse är byggt
## KATEGORI: API-REFERENS
Komplett referens för varje API-slutpunkt.
────────────────────────────────────────────────────────────
# Browser Proxy
SUMMARY: Tjänst för webbläsarautomatisering — separat Docker-container på port 13000 för headless webbläsarkontroll.
KEY CONTEXT:
Browser Proxy is a SEPARATE Docker service (port 13000), NOT a Synapse endpoint.
Synapse endpoints do NOT include /browser/* paths.
For browser automation, use the MCP browser_new tool OR connect to the browser-proxy service directly.
Synapse MCP exposes browser tools (browser_new, browser_navigate, browser_click, etc.)
Browser Proxy
Browser Proxy är en separat Docker-tjänst som tillhandahåller headless
webbläsarautomatisering via Playwright. Den är INTE en del av Synapse API
direkt — Synapse-endpoints inkluderar inte -sökvägar.
Arkitektur
[CODE BLOCK]
Åtkomstmetoder
Metod 1: Via Synapse MCP Server (rekommenderas)
Synapses MCP-server exponerar webbläsarverktyg som MCP-verktyg. Använd detta
för LLM-driven webbläsarautomatisering:
[CODE BLOCK]
Tillgängliga MCP-webbläsarverktyg:
- — öppna en ny webbläsarflik
- — navigera till en URL
- — klicka på ett element
- — skriv in text i ett fält
- — ta en skärmdump
- — stäng fliken
- (och fler — se MCP-integration)
Metod 2: Direkt åtkomst till Browser Proxy
För icke-MCP-integrationer, anslut direkt till browser-proxy-tjänsten:
[CODE BLOCK]
Vanliga användningsområden
Webb-skrapning
[CODE BLOCK]
Formulärautomatisering
[CODE BLOCK]
Skärmdumpar
[CODE BLOCK]
Relaterade tjänster
| Tjänst | Port | Syfte |
|---------|------|---------|
| Synapse API | 12800 | Minne, chatt, uppgifter |
| Synapse MCP | 13100 | MCP-server (79 verktyg) |
| Browser Proxy | 13000 | Headless webbläsarautomatisering |
| SSH Proxy | 12900 | SSH-åtkomst till fjärrmaskiner |
Nästa steg
- MCP-integration — hur man använder webbläsarverktyg via MCP
- Computer Control API — för GUI-automatisering på registrerade maskiner
────────────────────────────────────────────────────────────
# Chat API
SUMMARY: Asynkron chatt mellan människor och LLM-agenter — polla, svara, historik, antal olästa, filuppladdningar.
KEY CONTEXT:
Auth: Mind Key (agent side, ?role=agent) or JWT (human side, ?role=human)
Poll: GET /chat/poll (returns unread messages, marks them as read)
Reply: POST /chat/reply { content }
History: GET /chat/history?limit=50
Unread count: GET /chat/unread?role=agent (or ?role=human)
Upload: POST /chat/upload (multipart, file attachment)
Pattern: poll between tool calls, reply when human asks questions
Chat API
Chat API möjliggör asynkron meddelandehantering mellan människor och LLM-agenter.
Till skillnad från synkron chatt (ChatGPT-stil) kan människan lämna meddelanden
medan agenten arbetar — agenten pollar mellan verktygsanrop.
Hur det fungerar
[CODE BLOCK]
1. Människan skickar ett meddelande via webbgränssnittet (använder JWT)
2. Meddelandet lagras och markeras som oläst
3. Agenten pollar mellan verktygsanrop
4. Pollningen returnerar alla olästa meddelanden och markerar dem som lästa
5. Agenten bearbetar meddelandet och svarar eventuellt via
Endpoints
GET /chat/poll
Polla efter nya meddelanden från människan. Returnerar olästa meddelanden och
markerar dem som lästa. Använd detta mellan verktygsanrop.
[CODE BLOCK]
Svar:
[CODE BLOCK]
POST /chat/reply
Skicka ett meddelande som agenten.
[CODE BLOCK]
POST /chat/send
Skicka ett meddelande som människa (kräver JWT, inte Mind Key).
[CODE BLOCK]
GET /chat/history
Hämta den senaste chathistoriken (båda roller).
[CODE BLOCK]
GET /chat/unread
Hämta antal olästa meddelanden.
[CODE BLOCK]
GET /chat/status
Hämta chattsessionens status (tidsstämplar för senaste meddelande, antal olästa).
[CODE BLOCK]
POST /chat/upload
Ladda upp en filbilaga för ett specifikt meddelande (multipart-formulär).
[CODE BLOCK]
GET /chat/files/:messageid
Lista filbilagor för ett meddelande.
[CODE BLOCK]
GET /chat/file/:fileid
Ladda ner en filbilaga.
[CODE BLOCK]
Pollningsmönster
> [!TIP]
> Polla var 30–60 sekund mellan verktygsanrop. Polla inte oftare —
> det slösar API-kvot och ger ingen fördel.
[CODE BLOCK]
Nästa steg
- Tasks API
- Chat Polling Pattern
────────────────────────────────────────────────────────────
# Computer Control API
SUMMARY: Fjärrstyrning av registrerade datorer — köa kommandon, ta skärmdumpar, kör skript på fjärrmaskiner.
KEY CONTEXT:
Two sides: user-facing (Mind Key/JWT) and agent-facing (Computer Token)
Register agent: POST /computers/register { install_code } → returns computer_token
List: GET /computers/list (Mind Key or JWT)
Queue command: POST /computers/:id/commands { type, payload }
Command types: screenshot, click, move, type, key, scroll, drag
Agent poll: GET /computers/me/poll?wait=5 (Computer Token)
Agent result: POST /computers/me/commands/:cid/result (Computer Token)
One-shot screenshot: GET /computers/:id/screenshot (waits 30s for result)
Pattern: register agent on remote machine → user queues commands → agent polls and executes
Computer Control API
Computer Control API låter er fjärrstyra registrerade datorer. En liten agent
() körs på målmaskinen, pollar efter kommandon, kör dem
och skickar tillbaka resultat. Detta möjliggör LLM-driven GUI-automatisering.
Arkitektur
[CODE BLOCK]
Användarriktade endpoints (Mind Key eller JWT)
GET /computers/list
Lista alla registrerade datorer.
[CODE BLOCK]
GET /computers/:id
Hämta detaljer för en enskild dator.
[CODE BLOCK]
POST /computers/install-code
Generera en installationskod för att registrera en ny dator.
[CODE BLOCK]
Svar:
POST /computers/:id/commands
Köa ett kommando för fjärragenten att utföra.
[CODE BLOCK]
Svar:
GET /computers/:id/command (via query)
Köa ett kommando via GET (för enkla fall).
[CODE BLOCK]
GET /computers/:id/commands
Lista senaste kommandon för en dator.
[CODE BLOCK]
GET /computers/:id/commands/:cid
Hämta status + resultat för ett specifikt kommando.
[CODE BLOCK]
GET /computers/:id/screenshot
One-shot: köa ett skärmdumpskommando och vänta upp till 30 s på resultatet.
[CODE BLOCK]
POST /computers/:id/disable
Inaktivera en dator (återkallar dess token, behåller posten för granskning).
[CODE BLOCK]
DELETE /computers/:id
Ta bort en dator permanent.
[CODE BLOCK]
Agentriktade endpoints (Computer Token)
Dessa endpoints används av som körs på målmaskinen.
De använder en Computer Token (returnerad av ), inte en
Mind Key.
POST /computers/register
Lös in en installationskod och få en Computer Token.
[CODE BLOCK]
Svar:
> [!CRITICAL]
> Spara — den visas endast en gång och krävs för alla
> agentriktade endpoints.
GET /computers/me/poll
Lång-pollning efter nya kommandon. Agenten anropar denna i en loop.
[CODE BLOCK]
Returnerar omedelbart om kommandon väntar, eller efter sekunder om inte.
POST /computers/me/commands/:cid/result
Skicka resultatet av ett utfört kommando.
[CODE BLOCK]
Kommandotyper
| Typ | Payload | Beskrivning |
|------|---------|-------------|
| | | Fånga skärm som PNG (base64) |
| | | Klicka vid koordinater |
| | | Flytta musen till koordinater |
| | | Skriv in text vid markören |
| | | Tryck tangentkombination |
| | | Rulla hjulet |
| | | Dra och släpp |
Vanligt mönster: LLM-driven GUI-automatisering
[CODE BLOCK]
Nästa steg
- Browser Proxy — separat tjänst för webbläsarautomatisering
- Self-Hosted Agents Guide
────────────────────────────────────────────────────────────
# Cron & Scheduler
SUMMARY: Schemalägga återkommande API-anrop — cron-jobb som utlöses enligt ett schema, perfekt för periodisk synkronisering och påminnelser.
KEY CONTEXT:
Auth: Mind Key
Create: POST /cron { schedule, endpoint, method?, body?, headers?, enabled? }
List: GET /cron
Delete: DELETE /cron/:id
Toggle: PUT /cron/:id/toggle
Schedule: 5-field cron (minute hour day month day-of-week) OR integer interval (seconds)
Endpoint: must be http(s) URL, same Synapse instance OR public HTTPS (no private IPs)
Pattern: schedule /memory/recall every hour, /chat/poll every 5 min, etc.
Cron & Scheduler
Cron API låter er schemalägga återkommande HTTP-anrop till Synapse-endpoints
(eller externa HTTPS-endpoints). Perfekt för periodisk synkronisering,
påminnelser och underhållsuppgifter.
Endpoints
POST /cron
Skapa en schemalagd uppgift.
[CODE BLOCK]
Svar:
[CODE BLOCK]
GET /cron
Lista alla schemalagda uppgifter.
[CODE BLOCK]
DELETE /cron/:id
Ta bort en schemalagd uppgift.
[CODE BLOCK]
PUT /cron/:id/toggle
Aktivera eller inaktivera en uppgift utan att ta bort den.
[CODE BLOCK]
Schemasyntax
Standard cron (5 fält)
[CODE BLOCK]
Exempel:
| Schema | Betydelse |
|----------|---------|
| | Varje timme |
| | Var 15:e minut |
| | Veckodagar kl 09 |
| | Varje söndag vid midnatt |
| | Första dagen varje månad vid midnatt |
Heltalsintervall (sekunder)
För enkla intervall, ange ett heltal:
[CODE BLOCK]
Endpoint-restriktioner
> [!WARNING]
> Endpoints måste vara - eller -URL:er som pekar på:
> - Samma Synapse-instans (t.ex. )
> - Publika HTTPS-URL:er (inga privata IP-adresser, ingen localhost, inga metadata-IP:er)
Detta förhindrar SSRF-attacker där en komprometterad mind skulle kunna
schemalägga anrop till interna tjänster.
Vanliga mönster
Tertialvis minnesåterkallning (för LLM-agenter)
[CODE BLOCK]
Daglig säkerhetskopiering
[CODE BLOCK]
Periodisk chattpollning (var 5:e minut)
[CODE BLOCK]
Veckorapport-utlösare
[CODE BLOCK]
Nästa steg
- Variables API
- Webhooks API
────────────────────────────────────────────────────────────
# Fel & felhantering
SUMMARY: HTTP-statuskoder, format för felsvar och hur man återhämtar sig från vanliga fel.
KEY CONTEXT:
Error format: { statusCode, error, message, docs? }
Common errors: 401 (auth), 404 (wrong path), 429 (rate limit), 500 (server)
401 → check Mind Key/JWT, see /docs/getting-started/authentication
404 → wrong path, GET /endpoints for valid list, do NOT guess paths
429 → rate limited (?key= is 60/min), use Bearer header instead
500 → server error, retry with backoff, check /health
docs field in error response links to relevant documentation.
Fel & felhantering
Synapse använder standardiserade HTTP-statuskoder med ett konsekvent felsvarsformat.
Den här sidan förklarar hur man tolkar och återhämtar sig från fel.
Format för felsvar
Alla fel returnerar JSON med denna struktur:
[CODE BLOCK]
| Fält | Beskrivning |
|-------|-------------|
| | HTTP-statuskod |
| | HTTP-statusnamn |
| | Läsbar felbeskrivning för människor |
| | URL till relevant dokumentation (när tillämpligt) |
HTTP-statuskoder
200 OK
Lyckades. Begäran behandlades korrekt.
201 Created
Lyckades. En ny resurs skapades (t.ex. ).
204 No Content
Lyckades. Ingen body returnerades (t.ex. ).
400 Bad Request
Begäran var felaktig. Vanliga orsaker:
- Saknade obligatoriska JSON-fält
- Ogiltig JSON-syntax
- Ogiltigt enum-värde (t.ex. fel kategori)
[CODE BLOCK]
Lösning: Kontrollera begärans body mot API-dokumentationen. Se till att alla
obligatoriska fält finns med och har giltiga värden.
401 Unauthorized
Autentiseringen misslyckades. Vanliga orsaker:
- Saknad -header
- Ogiltig Mind Key eller JWT
- Användning av en Mind Key där JWT krävs (eller tvärtom)
[CODE BLOCK]
Lösning: Verifiera din token. Se Autentisering.
403 Forbidden
Ni är autentiserade men får inte utföra denna åtgärd. Vanliga orsaker:
- Försöker ta bort en annan användares mind
- Försöker verifiera ett minne med en Mind Key (kräver JWT)
- Mind är inaktiverad
Lösning: Kontrollera om ni använder rätt tokentyp för denna endpoint.
404 Not Found
Den begärda sökvägen eller resursen finns inte.
> [!CRITICAL]
> Gissa INTE endpointsökvägar. Endast de sökvägar som listas i
> existerar. Om ni får 404 använde ni en felaktig sökväg.
[CODE BLOCK]
Lösning: Anropa för att se listan över giltiga endpoints.
Jämför er URL mot listan tecken för tecken.
409 Conflict
Begäran är i konflikt med befintligt tillstånd. Vanliga orsaker:
- Försöker registrera med en e-postadress som redan finns
- Duplicerad webhook-URL
Lösning: Använd ett annat värde, eller använd för att uppdatera
befintlig resurs.
429 Too Many Requests
Ni nådde en hastighetsgräns. Gäller endast -queryparameter-autentisering
(60/min).
[CODE BLOCK]
Svarshuvuden:
[CODE BLOCK]
Lösning: Byt till -header (ingen hastighetsgräns),
eller vänta sekunder.
500 Internal Server Error
Serverfel. Detta bör inte inträffa — om det gör det är det en bugg.
Lösning:
1. Försök igen med exponentiell backoff (1 s, 2 s, 4 s, 8 s)
2. Kontrollera för att se om servern är uppe
3. Rapportera felet om det kvarstår
503 Service Unavailable
Servern är tillfälligt nere (t.ex. under driftsättning, databasmigrering).
Lösning: Vänta och försök igen. Kontrollera .
Återställningsmönster
Försök igen med exponentiell backoff
[CODE BLOCK]
Hantering av autentiseringsfel
[CODE BLOCK]
Vanliga felscenarier
"Mind Key fehlt oder ungültig"
- Ni glömde -headern
- Ni använde men nyckeln är fel
- Ni använder en JWT där en Mind Key krävs
"Route not found"
- Ni gissade en sökväg som inte finns
- Ni använde ett verb fel (t.ex. vs )
- Kontrollera för giltiga sökvägar
"Rate limit exceeded"
- Ni använder och överskred 60 req/min
- Byt till -header
Nästa steg
- Autentisering
- API-översikt
- Hastighetsgränser
────────────────────────────────────────────────────────────
# Memory API
SUMMARY: Komplett referens för de 22 minnes-endpoints: lagra, återkalla, söka, semantisk sökning, synkronisering, granskning och mer.
KEY CONTEXT:
Auth: Mind Key (Authorization: Bearer mk_xxx OR ?key=mk_xxx)
ALWAYS call GET /memory/recall at session start.
POST /memory with same category+key updates the existing memory.
Categories: identity, preference, fact, project, skill, mistake, context, note, credentials
Priorities: low, normal, high, critical
Search: GET /memory/search?q=... (FTS5 syntax: AND, OR, "phrases", prefix*)
Semantic: GET /memory/semantic-search?q=... (slower, conceptual)
Sync: GET /memory/diff?since=TIMESTAMP (incremental sync)
Export: GET /memory/mind-export (full JSON dump)
Memory API
Memory API är hjärtat i Synapse. Det tillhandahåller 22 endpoints för lagring,
hämtning, sökning och hantering av strukturerade minnen. Alla endpoints kräver
en Mind Key för autentisering.
> [!CRITICAL]
> Anropa alltid i början av varje session. Detta är
> det enda sättet att återuppbygga kontext från tidigare sessioner.
Kategorier
Minnen är organiserade i 8 kategorier:
| Kategori | Användningsområde |
|----------|----------|
| | Användarnamn, roll, kontaktinfo, inställningar om sig själv |
| | Tycker om, ogillar, arbetsstil, kommunikationsinställningar |
| | Verifierbara fakta (projektdetaljer, datum, URL:er) |
| | Projektstatus, milstolpar, arkitektur |
| | Saker användaren är bra på |
| | Tidigare fel — undvik att upprepa |
| | Sessionsrelevant kontext |
| | Diverse anteckningar |
Prioriteringar
- — bra att veta
- — standard
- — viktig
- — får aldrig glömmas (användaridentitet, juridisk info)
Centrala endpoints
GET /memory/recall
Returnerar ALLA minnen som LLM-optimerad oformaterad text. Anropa detta vid
varje sessionsstart.
[CODE BLOCK]
Svar (text/plain):
[CODE BLOCK]
POST /memory
Lagra ett nytt minne eller uppdatera ett befintligt (samma kategori + nyckel = uppdatering).
[CODE BLOCK]
Svar:
GET /memory
Lista minnen med valfria filter.
[CODE BLOCK]
PUT /memory/:id
Uppdatera ett specifikt minne via ID.
[CODE BLOCK]
DELETE /memory/:id
Ta bort ett enskilt minne.
[CODE BLOCK]
Sök-endpoints
GET /memory/search
Fulltextssökning med FTS5.
[CODE BLOCK]
FTS5-syntax:
- Flera ord = AND:
- Fras:
- Prefix:
- Boolesk:
- Uteslut:
GET /memory/semantic-search
Begreppsbaserad sökning med inbäddningar (langsammare än FTS5 men förstår betydelse).
[CODE BLOCK]
Returnerar minnen som är semantiskt lika frågan, även om inga nyckelord
matchar. Användbart för "hitta minnen om X" där X beskrivs på annat sätt.
GET /memory/by-tag
Lista minnen efter tagg.
[CODE BLOCK]
GET /memory/related/:id
Hitta minnen relaterade till ett specifikt minne (via gemensamma taggar).
[CODE BLOCK]
Synkronisering & Diff
GET /memory/diff
Inkrementell synk — returnerar minnen som ändrats sedan en tidsstämpel.
[CODE BLOCK]
Svar:
POST /memory/sync
Tillämpa en diff från en annan instans (för självvärd synk).
[CODE BLOCK]
Massåtgärder
POST /memory/bulk-delete
Ta bort flera minnen via ID.
[CODE BLOCK]
POST /memory/embed-batch
Generera inbäddningar för minnen som saknar dem (för semantisk sökning).
[CODE BLOCK]
GET /memory/embed-batch-status
Kontrollera förloppet för inbäddningsgenerering.
[CODE BLOCK]
Verifiering
Minnen har en -flagga. Agentlagrade minnen är som standard overifierade
(); människolagrade minnen är verifierade ().
POST /memory/verify
Markera ett minne som verifierat (kräver JWT, inte Mind Key).
[CODE BLOCK]
POST /memory/unverify
Markera ett minne som overifierat (kräver JWT).
[CODE BLOCK]
GET /memory/unverified
Lista minnen som väntar på mänsklig verifiering.
[CODE BLOCK]
Statistik & granskning
GET /memory/stats
Aggregerad statistik för den aktuella minden.
[CODE BLOCK]
Returnerar:
GET /memory/audit
Granskningslogg över alla tillståndsändrande åtgärder.
[CODE BLOCK]
GET /memory/contradictions
Upptäck potentiella motsägelser i lagrade minnen.
[CODE BLOCK]
GET /memory/expiring
Lista minnen med utgångsdatum som närmar sig.
[CODE BLOCK]
Hälsa & export
GET /memory/health
Snabb hälsokontroll för minnessystemet.
[CODE BLOCK]
GET /memory/mind-export
Full JSON-export av alla minnen (för säkerhetskopiering).
[CODE BLOCK]
POST /memory/compact
Komprimera liknande minnen (auto-sammanfattning).
[CODE BLOCK]
Nästa steg
- Snabbstart för LLM:er
- Minnesbästa praxis
- FTS5-sökning
- Semantisk sökning
────────────────────────────────────────────────────────────
# API-översikt & bas-URL
SUMMARY: Alla Synapse API-endpoints, bas-URL, autentiseringsmönster och svarsformat i korthet.
KEY CONTEXT:
Base URL: https://synapse.schaefer.zone
Auth: Authorization: Bearer YOUR_MIND_KEY (header, no rate limit)
OR ?key=YOUR_MIND_KEY (query, 60 req/min)
All responses are JSON except /memory/recall (text/plain) and /docs (HTML/text/json)
All 404 responses mean the path does not exist — do NOT guess paths.
GET /endpoints returns machine-readable list of all valid endpoints.
API-översikt & bas-URL
Synapse API är ett RESTful HTTP-API. Alla endpoints returnerar JSON (utom där
angivet). Den här sidan täcker det ni behöver veta innan ni dyker in i specifika
endpoints.
Bas-URL
[CODE BLOCK]
Alla sökvägar i denna dokumentation är relativa till denna bas-URL. För
självvärdda instanser, ersätt med er egen URL.
Autentisering
Två metoder, båda skickade via -header:
[CODE BLOCK]
Eller via queryparameter (hastighetsbegränsad till 60/min):
[CODE BLOCK]
Se Autentisering för detaljer.
Endpoint-grupper
| Grupp | Autentisering | Beskrivning |
|-------|------|-------------|
| Publik | Ingen | Landningssida, hälsa, OpenAPI, dokumentation |
| Memory | Mind Key | CRUD, sökning, synk, inbäddningar |
| Chat | Mind Key / JWT | Asynkrona meddelanden mellan människa och agent |
| Tasks | Mind Key | Uppgiftshantering |
| Scripts | Mind Key / JWT | Beständig skriptlagring |
| Scheduler | Mind Key | Cron-jobb + variabler |
| Webhooks | Mind Key | HTTP-återanrop vid händelser |
| Computers | Mind Key / JWT | Fjärrstyrning av datorer |
| User/Minds | JWT | Konto + mind-hantering |
| Sharing | JWT | Mind-delning mellan användare |
| Push | JWT | Web Push-prenumerationer |
| Tools | Ingen | Tid, kalkyl, slump (publika verktyg) |
Svarsformat
- JSON (standard):
- Oformaterad text: returnerar LLM-optimerad text
- HTML: , , , ,
Standard kuvert för svar
Lyckade svar returnerar datan direkt:
[CODE BLOCK]
Felsvar använder detta format:
[CODE BLOCK]
> [!NOTE]
> Fältet länkar till relevant dokumentation för vanliga fel.
HTTP-statuskoder
| Kod | Betydelse |
|------|---------|
| 200 | Lyckades (GET, PUT) |
| 201 | Skapad (POST) |
| 204 | Inget innehåll (DELETE) |
| 400 | Felaktig begäran (valideringsfel) |
| 401 | Obehörig (saknas/ogiltig token) |
| 403 | Förbjuden (fel tokentyp) |
| 404 | Hittades inte (sökvägen finns inte) |
| 409 | Konflikt (dubblett) |
| 429 | För många begäranden (hastighetsgräns) |
| 500 | Serverfel |
Upptäckbarhets-endpoints
| Endpoint | Syfte |
|----------|---------|
| | Landningssida (LLM-optimerad) |
| | Maskinläsbar lista över alla endpoints |
| | Ofärmaterad endpoint-lista |
| | OpenAPI 3.0-specifikation |
| | Fullständig API-dokumentation (HTML) |
| | API-dokumentation som JSON |
| | Dokumentationssystem (HTML) |
| | Dokumentationsindex (JSON) |
| | All dokumentation som ett textblock |
| | Interaktiv API-playground |
Hastighetsgränser
| Autentiseringsmetod | Gräns |
|-------------|-------|
| Mind Key (header) | Ingen |
| Mind Key (?key=) | 60/min per IP |
| JWT (header) | Ingen |
| Publika endpoints | Ingen |
Hastighetsbegränsade svar inkluderar:
[CODE BLOCK]
Paginering
List-endpoints stöder och :
[CODE BLOCK]
Standardgräns: 100. Maxgräns: 500.
CORS
Alla endpoints stöder CORS för webbläsarbaserade klienter:
[CODE BLOCK]
SDK:er & klienter
- Node.js SDK: (repo)
- MCP Server: (repo)
- HTTP-klient: valfritt HTTP-bibliotek (curl, fetch, axios, etc.)
Nästa steg
- Memory API — de viktigaste endpoints
- Chat API — asynkron kommunikation mellan människa och agent
- Fel & felhantering
────────────────────────────────────────────────────────────
# Hastighetsgränser & kvoter
SUMMARY: Principer för hastighetsgränser i Synapse API — Bearer-header (obegränsat), ?key= (60/min), publika endpoints.
KEY CONTEXT:
Mind Key (Authorization: Bearer header) → NO rate limit
Mind Key (?key= query param) → 60 req/min per IP
JWT (Authorization: Bearer header) → NO rate limit
Public endpoints (/tools/*, /docs, /health, /endpoints) → NO rate limit
Rate limit headers: X-RateLimit-Limit, X-RateLimit-Remaining, Retry-After
Recommendation: ALWAYS use Authorization header. Use ?key= only for URL-only tools.
Hastighetsgränser & kvoter
Synapse har en enkel, förutsägbar princip för hastighetsgränser som utformats
för att förhindra missbruk utan att vara i vägen för legitim användning.
Princip för hastighetsgränser
| Autentiseringsmetod | Gräns | Omfattning |
|-------------|-------|-------|
| Mind Key () | Ingen | Per-mind |
| Mind Key () | 60 req/min | Per-IP |
| JWT () | Ingen | Per-användare |
| Publika endpoints | Ingen | Global |
> [!TIP]
> Använd alltid -headern när det är möjligt. Den har
> ingen hastighetsgräns. Använd endast för verktyg som inte kan sätta
> egna headers.
Headers för hastighetsgränser
När ni använder -autentisering inkluderar svar headers för hastighetsgräns:
[CODE BLOCK]
När ni överskrider gränsen:
[CODE BLOCK]
När ni når en hastighetsgräns
Om ni får en 429:
1. Byt till Authorization-header (rekommenderas):
[CODE BLOCK]
2. Eller vänta sekunder och försök igen.
Varför ?key=-gränsen finns
Queryparametern är bekväm för URL-endast-verktyg (webbläsare,
-kommandon), men har säkerhets- och prestandakonsekvenser:
- Säkerhet: Queryparametrar loggas i serverns åtkomstloggar,
webbläsarhistorik och Referer-headers. Begränsad användning minskar exponeringen.
- Prestanda: Queryparameter-autentisering kräver en IP-baserad
hastighetsbegränsare (Redis-uppslag per begäran), vilket lägger till latens.
Header-autentisering hoppar över detta.
- Missbruksförebyggande: En läckt -URL skulle kunna delas och
överbelastas. IP-gränsen begränsar skadeomfånget.
Rekommenderade mönster
LLM-agenter
[CODE BLOCK]
Webbläsarbaserade verktyg
Om ert verktyg bara kan öppna URL:er:
[CODE BLOCK]
MCP-server
MCP-servrar använder alltid header-autentisering via miljövariabeln
— ingen hastighetsgräns gäller.
Massimport
För massåtgärder (t.ex. import av 1000 minnen), använd alltid header-autentisering.
Massimport via når hastighetsgränsen inom 1 minut.
Kvoter (Mind-nivå)
Det finns för närvarande inga kvoter per mind för lagringsstorlek eller antal
minnen. Alla gränser är på auth/IP-nivå, inte datanivå. Detta kan ändras i
framtiden för rättvisa i miljöer med flera användare.
Övervaka er användning
[CODE BLOCK]
Nästa steg
- Autentisering
- Fel & felhantering
────────────────────────────────────────────────────────────
# Scripts API
SUMMARY: Beständig skriptlagring — spara återanvändbara shell-, Python- eller Node-skript och hämta dem via curl | bash.
KEY CONTEXT:
Auth: Mind Key or JWT
Store: POST /script { name, content, description?, language? }
Fetch as text: GET /script/:name (returns text/plain, curl | bash ready)
Info: GET /script/:name/info (metadata without content)
List: GET /scripts (JSON array)
Delete: DELETE /script/:name
Use case: store deployment scripts, config generators, troubleshooting snippets
Scripts API
Scripts API tillhandahåller ett beständigt lager för återanvändbara skript.
Skript är namngivna och versionshanterade inom en mind och kan hämtas som
oformaterad text — perfekt för -mönster.
Endpoints
POST /script
Lagra eller uppdatera ett skript.
[CODE BLOCK]
GET /script/:name
Hämta skriptinnehåll som . Perfekt för att pipa till bash.
[CODE BLOCK]
GET /script/:name/info
Hämta skriptmetadata utan innehållet.
[CODE BLOCK]
Svar:
[CODE BLOCK]
GET /scripts
Lista alla skript i den aktuella minden.
[CODE BLOCK]
DELETE /script/:name
Ta bort ett skript.
[CODE BLOCK]
Vanliga användningsområden
Driftsättningsskript
Lagra standardiserade driftsättningsprocedurer så att LLM:en kan köra dem utan
att härleda stegen varje gång:
[CODE BLOCK]
Felsökningsavsnitt
Lagra diagnostikkommandon för vanliga problem:
[CODE BLOCK]
Konfigurationsgeneratorer
Lagra skript som genererar konfigurationer:
[CODE BLOCK]
Nästa steg
- Variables API
- Cron & Scheduler
────────────────────────────────────────────────────────────
# Tasks API
SUMMARY: Uppgiftshantering för LLM-agenter — skapa, lista, uppdatera, slutför, ta bort uppgifter med prioriteringar.
KEY CONTEXT:
Auth: Mind Key
List: GET /mind/tasks?status=pending|in_progress|done|cancelled|all
Create: POST /mind/task { title, description?, priority?, due_at? }
Update: PUT /mind/task/:id { title?, description?, priority?, status?, due_at? }
Complete: GET /mind/task/:id/complete
Delete: GET /mind/task/:id/delete
Priorities: low, normal, high, critical
Statuses: pending, in_progress, done, cancelled
Pattern: create tasks for multi-step work, update status as you progress
Tasks API
Tasks API ger LLM-agenter ett strukturerat sätt att spåra arbete i flera steg.
Uppgifter är begränsade till den aktuella minden och bevaras mellan sessioner,
så agenten kan återuppta arbetet där den slutade.
Endpoints
GET /mind/tasks
Lista alla uppgifter för den aktuella minden.
[CODE BLOCK]
Svar:
[CODE BLOCK]
POST /mind/task
Skapa en ny uppgift.
[CODE BLOCK]
GET /mind/task (query params)
Skapa en uppgift via GET (för URL-endast-verktyg).
[CODE BLOCK]
PUT /mind/task/:id
Uppdatera en befintlig uppgift.
[CODE BLOCK]
GET /mind/task/:id/complete
Markera en uppgift som slutförd.
[CODE BLOCK]
GET /mind/task/:id/delete
Ta bort en uppgift permanent.
[CODE BLOCK]
Prioriteringar
- — inte brådskande
- — standard
- — viktig
- — måste göras omedelbart
Statusar
- — skapad, inte startad
- — pågår
- — slutförd
- — övergiven
Mönster: Uppgiftsdrivet arbetsflöde
[CODE BLOCK]
Nästa steg
- Uppgiftsdrivet arbetsflöde
- Cron & Scheduler
────────────────────────────────────────────────────────────
# Verktyg (tid, kalkyl, slump)
SUMMARY: Publika verktygs-endpoints — servertid, säker kalkylator, slumpvärdesgenerator. Ingen autentisering krävs.
KEY CONTEXT:
No auth required for any /tools/* endpoint.
GET /tools/time → { time, timezone, offset }
GET /tools/calc?expr=(10+5)*3 → { result, expr } (safe, no eval, arithmetic only)
GET /tools/random?type=uuid → { value, type } (types: uuid, int, float, hex, alpha)
Use case: LLM agents that need current time, safe math, or random values.
Verktyg
-endpoints är publika verktyg — ingen autentisering krävs.
De är användbara för LLM-agenter som behöver servertid, säker matematik eller
slumpvärden.
GET /tools/time
Hämta aktuell servertid, tidszon och UTC-offset.
[CODE BLOCK]
Svar:
[CODE BLOCK]
Användningsområde: LLM-agenter som behöver veta "vilken tid är det nu" för
schemaläggning, tidsstämplar eller relativa datumberäkningar.
GET /tools/calc
Säker kalkylator — endast aritmetik, ingen . Stöder , , , ,
, , och tal.
[CODE BLOCK]
Svar:
[CODE BLOCK]
> [!TIP]
> Använd detta istället för att försöka räkna i huvudet eller via strängtolkning.
> Det är säkert (ingen kodinjektion möjlig) och korrekt.
Operatorer som stöds
- addition
- subtraktion
- multiplikation
- division
- modulo
- parenteser
- Tal (heltal och decimaler)
Exempel
[CODE BLOCK]
GET /tools/random
Generera slumpvärden.
[CODE BLOCK]
Typ-parametrar
| Typ | Parametrar | Utdata |
|------|-----------|--------|
| | inga | UUID v4-sträng |
| | , (standard 0-100) | Heltal |
| | , (standard 0-100) | Flyttal |
| | , (längdintervall, standard 8-16) | Hex-sträng |
| | , (längdintervall, standard 8-16) | Alfabetisk sträng |
Användningsområden för LLM-agenter
Generera unika ID:n
[CODE BLOCK]
Beräkna procentandelar
[CODE BLOCK]
Hämta aktuell tidsstämpel
[CODE BLOCK]
Generera testdata
[CODE BLOCK]
Nästa steg
- API-översikt — alla endpoint-grupper
- Fel & felhantering
────────────────────────────────────────────────────────────
# User & Minds API
SUMMARY: Kontohantering — registrera, logga in, skapa minds, lista minds, ta bort minds. JWT-skyddad.
KEY CONTEXT:
Auth: JWT (from /register or /login)
Register: POST /register { email, password, display_name? } → returns JWT
Login: POST /login { email, password } → returns JWT
Create mind: POST /minds { name, description? } → returns mind_key (shown once!)
List minds: GET /minds
Delete mind: DELETE /minds/:id (irreversible — deletes all memories!)
JWT expires after 7 days. Mind Key never expires.
Mind Key is shown only once at creation — save it permanently.
User & Minds API
User & Minds API hanterar kontohantering. Dessa endpoints använder
JWT-autentisering (inte Mind Keys) eftersom de opererar på kontonivå, inte
mind-nivå.
Autentiserings-endpoints
POST /register
Skapa ett nytt användarkonto.
[CODE BLOCK]
Svar:
[CODE BLOCK]
POST /login
Logga in på ett befintligt konto.
[CODE BLOCK]
Svar: samma som .
Minds-endpoints
POST /minds
Skapa en ny mind. Returnerar Mind Key — spara den omedelbart, den visas
endast en gång.
[CODE BLOCK]
Svar:
[CODE BLOCK]
> [!CRITICAL]
> visas endast en gång. Om ni tappar den kan ni inte hämta den —
> ni måste ta bort minden och skapa en ny (vilket förlorar alla lagrade minnen).
GET /minds
Lista alla minds för den aktuella användaren.
[CODE BLOCK]
Svar:
[CODE BLOCK]
DELETE /minds/:id
Ta bort en mind permanent.
[CODE BLOCK]
> [!WARNING]
> Att ta bort en mind är oåterkalleligt. Alla minnen, uppgifter,
> chathistorik och skript i den minden förloras permanent. Exportera först via
> om ni behöver en säkerhetskopia.
Flera-mind-mönster
De flesta användare har nytta av flera minds för att hålla kontexter isolerade:
[CODE BLOCK]
Använd olika Mind Keys i olika LLM-sessioner för att hålla kontexterna isolerade.
Kontosäkerhet
Lösenordskrav
- Minst 6 tecken
- Ingen maxgräns (använd en lösenordshanterare)
- Lagras som bcrypt-hash (aldrig i klartext)
JWT-utgång
JWT:er löper ut efter 7 dagar. När de löpt ut, anropa igen.
Mind Key-säkerhet
Mind Keys löper aldrig ut. Om en Mind Key komprometteras:
1. Skapa en ny mind via
2. Uppdatera er LLM-konfiguration med den nya Mind Key
3. Ta bort den komprometterade minden via
Nästa steg
- Autentisering — fullständig auth-guide
- Mind Key vs JWT — beslutsguide
- Sharing API — dela minds med andra användare
────────────────────────────────────────────────────────────
# Variables API
SUMMARY: Snabbt nyckel-värde-lager för LLM-tillstånd — räknare, flaggor, tidsstämplar för senast sedd, partiella förlopp.
KEY CONTEXT:
Auth: Mind Key
Set: POST /var { key, value }
Get: GET /var/:key
List: GET /var
Delete: DELETE /var/:key
Use case: store last-seen timestamps, counters, flags, partial workflow state
Faster than memory (PostgreSQL direct, no FTS5 indexing)
Not for: structured facts (use /memory), long content (use /script)
Variables API
Variables API är ett snabbt nyckel-värde-lager för efemärt tillstånd. Till
skillnad från minnen (som indexeras, är sökbara och strukturerade) är variabler
optimerade för snabb läs/skriv-åtkomst — perfekt för räknare, flaggor och
sessionstillstånd.
Endpoints
POST /var
Sätt eller uppdatera en variabel.
[CODE BLOCK]
GET /var/:key
Hämta en enskild variabel.
[CODE BLOCK]
Svar:
[CODE BLOCK]
GET /var
Lista alla variabler.
[CODE BLOCK]
DELETE /var/:key
Ta bort en variabel.
[CODE BLOCK]
När variabler ska användas vs minne
| Användningsområde | Använd |
|----------|-----|
| Användarnamn, inställningar | Minne (sökbart, strukturerat) |
| Tidsstämpel för senaste session | Variabel (efemärt tillstånd) |
| Räknare (t.ex. skickade meddelanden) | Variabel (frekventa uppdateringar) |
| Arbetsflödestillstånd ("steg 3 av 5 klart") | Variabel (övergående) |
| Långformiga projektanteckningar | Minne (fulltextindexerat) |
| Återanvändbara skript | Skriptlager (namngivet, versionshanterat) |
Vanliga mönster
Spåra senaste session
[CODE BLOCK]
Räknarmönster
[CODE BLOCK]
Funktionsflaggor
[CODE BLOCK]
Nästa steg
- Memory API — för strukturerad, sökbar data
- Cron & Scheduler
────────────────────────────────────────────────────────────
# Webhooks API
SUMMARY: Registrera HTTP-återanrop för minnes-, chatt- och uppgiftshändelser — bli meddelad när data ändras.
KEY CONTEXT:
Auth: Mind Key
Register: POST /webhooks { url, events, secret? }
List: GET /webhooks
Get: GET /webhooks/:id
Update: PUT /webhooks/:id { url?, events?, secret?, enabled? }
Delete: DELETE /webhooks/:id
Events: memory.*, memory.store, memory.update, memory.delete, chat.*, chat.message_received, task.*, task.created, task.completed
Secret: HMAC-SHA256 signed payload, sent in X-Synapse-Signature header
Pattern: register webhook → receive POST → process event → call Synapse API
Webhooks API
Webhooks låter er ta emot HTTP-återanrop när händelser sker i Synapse. Perfekt
för att utlösa extern automatisering, skicka aviseringar eller synkronisera till
andra system.
Endpoints
POST /webhooks
Registrera en ny webhook.
[CODE BLOCK]
Svar:
[CODE BLOCK]
GET /webhooks
Lista alla webhooks för den aktuella minden.
[CODE BLOCK]
GET /webhooks/:id
Hämta en enskild webhook.
[CODE BLOCK]
PUT /webhooks/:id
Uppdatera en webhook (URL, händelser, secret eller enabled-flagga).
[CODE BLOCK]
DELETE /webhooks/:id
Ta bort en webhook.
[CODE BLOCK]
Händelsetyper
| Mönster | Utlöses när |
|---------|------------|
| | Vilken minneshändelse som helst |
| | Nytt minne lagrat |
| | Minne uppdaterat |
| | Minne borttaget |
| | Vilken chatthändelse som helst |
| | Nytt meddelande från människa |
| | Vilken uppgiftshändelse som helst |
| | Ny uppgift skapad |
| | Uppgift markerad som slutförd |
| | Alla händelser |
Webhook-payload
När en händelse utlöses gör Synapse en POST till er URL:
[CODE BLOCK]
Signaturverifiering
Om ni sätter en signerar Synapse varje payload med HMAC-SHA256:
[CODE BLOCK]
Verifiera i er hanterare:
[CODE BLOCK]
Mönster: Realtidssynk
[CODE BLOCK]
Nästa steg
- Cron & Scheduler
- Guide för webhook-automatisering
## KATEGORI: MCP-INTEGRATION
Integration med Claude, Cursor och andra MCP-klienter.
────────────────────────────────────────────────────────────
# MCP i Claude Code
SUMMARY: Använd Synapse-verktyg från Claude Codes terminalagent — beständigt minne för kodsessioner.
KEY CONTEXT:
Claude Code config: ~/.claude/config.json (or via `claude mcp add` command)
Command: npx -y synapse-mcp-api@latest
Env: SYNAPSE_MIND_KEY (required), SYNAPSE_URL (optional)
Alternative: `claude mcp add synapse -- npx -y synapse-mcp-api@latest`
Then: set SYNAPSE_MIND_KEY env var in your shell
Test: in claude code, type "recall all my memories"
MCP i Claude Code
Claude Code är Anthropics terminalbaserade kodagent. Med Synapse MCP får Claude
Code beständigt minne över kodsessioner — den minns er projektkontext, tidigare
beslut och kodmönster.
Konfiguration
Metod 1: CLI-kommando (rekommenderas)
[CODE BLOCK]
Metod 2: Redigera konfigurationsfil
Redigera :
[CODE BLOCK]
Verifiera att det fungerar
Starta Claude Code:
[CODE BLOCK]
I Claude Code-prompten, skriv:
[CODE BLOCK]
Claude bör anropa och svara med era lagrade minnen.
Vanliga mönster
Projektkontext-beständighet
I början av en kodsession:
[CODE BLOCK]
Claude anropar , ser er projektlista och fortsätter arbetet
där ni slutade.
Kodbeslut
När ni fattar ett arkitektoniskt beslut:
[CODE BLOCK]
Claude anropar med kategori , prioritet .
Undvika tidigare misstag
[CODE BLOCK]
Claude söker minnen med kategori och påminner om tidigare fel.
Uppgiftsspårning
[CODE BLOCK]
Claude anropar och uppgiften persistens över sessioner.
Verktygsprofiler
För kodsessioner där ni inte behöver alla 119 verktyg:
[CODE BLOCK]
Felsökning
MCP-server startar inte
[CODE BLOCK]
Mind Key känns inte igen
[CODE BLOCK]
Claude Code ser inte verktyg
- Starta om Claude Code efter konfigurationsändringar
- Kontrollera för att verifiera att Synapse är registrerad
- Se MCP-felsökning
Nästa steg
- Claude Desktop-konfiguration
- Cursor-konfiguration
- Guide för beständig LLM-agent
────────────────────────────────────────────────────────────
# MCP i Claude Desktop
SUMMARY: Anslut Synapse till Claude Desktop på 2 minuter. Claude får 79 Synapse-verktyg inbyggt.
KEY CONTEXT:
Config file: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
%APPDATA%\Claude\claude_desktop_config.json (Windows)
MCP server command: npx -y synapse-mcp-api@latest
Env vars: SYNAPSE_MIND_KEY (required), SYNAPSE_URL (optional, default https://synapse.schaefer.zone)
After config: restart Claude Desktop, check for 🔌 icon with "79 tools"
Test: type "memory_recall aufrufen" in a new chat
Troubleshooting: Node.js ≥ 18, check Mind Key, see /docs/mcp/troubleshooting
MCP i Claude Desktop
Claude Desktop är Anthropics skrivbordsapp för macOS och Windows. Med Synapse
MCP-server konfigurerad får Claude inbyggd åtkomst till alla 79 Synapse-verktyg
— den kan lagra minnen, återkalla dem, hantera uppgifter, chatta med er och mer.
Förutsättningar
- Claude Desktop-app (macOS eller Windows)
- Node.js 18+ installerat ()
- Er Synapse Mind Key
Steg 1: Öppna konfigurationsfilen
- macOS:
- Windows:
Om filen inte finns, skapa den.
Steg 2: Lägg till Synapse MCP-server
[CODE BLOCK]
> [!TIP]
> Om ni redan har andra MCP-servrar konfigurerade, lägg bara till
> -blocket inuti det befintliga -objektet.
Steg 3: Starta om Claude Desktop
1. Avsluta Claude Desktop helt (Cmd+Q på macOS, inte bara stäng fönstret)
2. Öppna Claude Desktop igen
3. Starta en ny chatt
4. Leta efter 🔌-pluggikonen nere till vänster — den bör visa "79 tools"
Steg 4: Testa det
I en ny chatt, skriv:
[CODE BLOCK]
Claude bör anropa verktyget och svara med en sammanfattning av
era lagrade minnen (eller "No memories yet" om er mind är tom).
Tillgängliga verktyg (urval)
| Verktyg | Beskrivning |
|------|-------------|
| | Återkalla alla minnen |
| | Lagra ett nytt minne |
| | Sök minnen |
| | Lista uppgifter |
| | Skapa en uppgift |
| | Kontrollera efter nya meddelanden |
| | Svara på ett meddelande |
| | Öppna en webbläsarflik |
| | Lista registrerade datorer |
Fullständig lista: Vad är MCP?
Felsökning
Inga verktyg visas i Claude Desktop
1. Verifiera Node.js-version: (måste vara ≥ 18)
2. Kontrollera att konfigurationsfilen är giltig JSON (inga avslutande kommatecken)
3. Starta om Claude Desktop helt (Cmd+Q, inte bara stäng)
4. Kontrollera Claude Desktop-loggar: (macOS)
"Mind Key invalid"-fel
- Verifiera att börjar med
- Hämta en ny nyckel via (kräver JWT från )
- Inga citattecken runt nyckeln i JSON
npx hittades inte
- Installera Node.js 18+:
- Starta om terminal efter installation
- På macOS med Homebrew:
Verktyg visas men anrop misslyckas
- Kontrollera att är nåbar:
- Verifiera att er Mind Key fungerar:
- Se MCP-felsökning
Verktygsprofiler (spara tokens)
Om ni använder en mindre LLM eller vill spara kontext-tokens, sätt en verktygsprofil:
[CODE BLOCK]
Profiler: (8 verktyg), (25), (119, standard).
Nästa steg
- Claude Code-konfiguration
- Cursor-konfiguration
- MCP-felsökning
────────────────────────────────────────────────────────────
# MCP i Continue.dev
SUMMARY: Anslut Synapse till Continue.dev — öppen källkod AI-kodningsassistent för VS Code och JetBrains.
MCP i Continue.dev
Continue.dev är en öppen källkod AI-kodningsassistent för VS Code och
JetBrains IDE:er. Med Synapse MCP får Continue beständigt minne över sessioner.
Förutsättningar
- VS Code eller JetBrains IDE
- Continue.dev-tillägg installerat
- Node.js 18+
- Er Synapse Mind Key
Konfiguration
Steg 1: Öppna Continue-konfiguration
I VS Code eller JetBrains:
1. Öppna Continue-tilläggets sidopanel
2. Klicka på kugghjulsikonen → "Open config.json"
Eller redigera direkt.
Steg 2: Lägg till Synapse MCP-server
[CODE BLOCK]
Steg 3: Ladda om Continue
Ladda om VS Code-fönstret (Cmd+Shift+P → "Reload Window") eller starta om er IDE.
Verifiera att det fungerar
I Continue-chatten:
[CODE BLOCK]
Continue bör anropa och svara med era lagrade minnen.
Vanliga mönster
Projektkontext
[CODE BLOCK]
Continue anropar , ser era projektminnen och fortsätter arbetet
där ni slutade.
Kodgranskningsmönster
[CODE BLOCK]
Continue hittar era lagrade kodgranskningsmönster och tillämpar dem.
Parprogrammeringsminne
[CODE BLOCK]
Continue lagrar det som ett -minne.
Felsökning
MCP-server ansluter inte
1. Kontrollera att är giltig JSON
2. Verifiera Node.js:
3. Kontrollera Continues utdatapanel (View → Output → Continue)
4. Starta om IDE
Verktyg visas inte
- Verifiera att Continue-version stöder MCP (≥ 0.9.x)
- Kontrollera att -miljövariabel är satt i konfigurationen
- Leta efter MCP-fel i Continues loggar
Nästa steg
- Claude Desktop-konfiguration
- Anpassad MCP-klient
────────────────────────────────────────────────────────────
# MCP i Cursor
SUMMARY: Anslut Synapse till Cursor IDE för beständigt projektminne över kodsessioner.
MCP i Cursor
Cursor är en AI-driven IDE baserad på VS Code. Med Synapse MCP får Cursor
beständigt minne över sessioner — den minns era projektbeslut, kodmönster och
tidigare felsökningssessioner.
Förutsättningar
- Cursor IDE installerad ()
- Node.js 18+
- Er Synapse Mind Key
Konfiguration
Steg 1: Öppna Cursor-inställningar
I Cursor:
1. Öppna Inställningar (Cmd+, på macOS, Ctrl+, på Windows/Linux)
2. Sök efter "MCP" eller navigera till
Steg 2: Lägg till Synapse MCP-server
Klicka "Add MCP Server" och konfigurera:
| Fält | Värde |
|-------|-------|
| Name | |
| Type | |
| Command | |
| Env | |
Steg 3: Redigera config.json direkt (alternativ)
Cursor lagrar MCP-konfiguration i :
[CODE BLOCK]
Steg 4: Starta om Cursor
Starta om Cursor helt (Cmd+Q och öppna igen på macOS).
Verifiera att det fungerar
I Cursors chattpanel (Cmd+L):
[CODE BLOCK]
Cursor bör anropa och svara med era lagrade minnen.
Vanliga mönster
Projekt-onboarding
När ni öppnar ett nytt projekt:
[CODE BLOCK]
Cursor anropar och fortsätter arbetet där ni slutade.
Arkitekturbeslut
[CODE BLOCK]
Cursor lagrar det som ett -minne med prioritet.
Felsökningshistorik
[CODE BLOCK]
Cursor söker efter -minnen och påminner om tidigare fixar.
Kodmönster över sessioner
[CODE BLOCK]
Cursor hittar minnen om auth-implementeringar ni har gjort tidigare.
Felsökning
MCP-server ansluter inte
1. Verifiera Node.js: (≥ 18)
2. Testa MCP-server: (borde starta utan fel)
3. Kontrollera Cursors MCP-loggar (View → Output → MCP)
4. Starta om Cursor helt
Verktyg visas inte
- Kontrollera att är giltig JSON
- Verifiera att -miljövariabel är satt
- Kontrollera att Cursor-version stöder MCP (≥ 0.42)
Ogiltig Mind Key
[CODE BLOCK]
Nästa steg
- Claude Desktop-konfiguration
- Continue.dev-konfiguration
- Guide för beständig LLM-agent
────────────────────────────────────────────────────────────
# Bygg en anpassad MCP-klient
SUMMARY: Anslut till Synapse MCP-servern från er egen applikation med MCP-SDK:et.
Bygg en anpassad MCP-klient
Om ni bygger er egen LLM-applikation kan ni ansluta till Synapse MCP-servern
direkt med det officiella MCP-SDK:et. Detta ger er app åtkomst till alla 79
Synapse-verktyg.
SDK:er
| Språk | Paket |
|----------|---------|
| TypeScript/JavaScript | |
| Python | |
TypeScript-exempel
Installation
[CODE BLOCK]
Anslut via stdio
[CODE BLOCK]
Anslut via HTTP/SSE (fjärr)
[CODE BLOCK]
Python-exempel
Installation
[CODE BLOCK]
Anslut via stdio
[CODE BLOCK]
Verktygsprofiler
Vid anslutning kan ni begära en specifik verktygsprofil via headern
(HTTP/SSE) eller miljövariabeln (stdio):
[CODE BLOCK]
Felhantering
[CODE BLOCK]
Användningsområden
- Anpassade AI-assistenter — bygg er egen agent med beständigt minne
- Arbetsflödesautomation — kedja Synapse-verktyg i anpassade arbetsflöden
- Datapipelines — extrahera minnen, transformera, ladda annanstans
- Övervakningsinstrumentpaneler — visa minnesstatistik, chatthistorik, uppgifter
Nästa steg
- MCP-specifikation
- Synapse MCP-repo
- API-översikt
────────────────────────────────────────────────────────────
# MCP-felsökning
SUMMARY: Lös vanliga MCP-integrationsproblem — server startar inte, verktyg visas inte, auth-fel.
KEY CONTEXT:
Common issues:
1. Node.js < 18 → upgrade to 18+
2. Mind Key invalid → check format (mk_...), get fresh via POST /minds
3. npx not found → install Node.js
4. Tools not appearing → restart client, check config JSON validity
5. SYNAPSE_URL unreachable → curl /health to verify
6. MCP server crashes → check logs, run npx manually to see error
Debug steps: run `npx -y synapse-mcp-api@latest` manually, check stderr
Logs: Claude Desktop ~/Library/Logs/Claude/mcp.log, Cursor ~/.cursor/logs/
MCP-felsökning
Vanliga problem och lösningar vid integration av Synapse MCP med er LLM-klient.
Snabb checklista för diagnostik
1. ✅ Node.js 18+ installerat? ()
2. ✅ Mind Key börjar med ? (inte JWT )
3. ✅ Synapse API nåbart? ()
4. ✅ Mind Key fungerar? ()
5. ✅ Konfigurationsfil är giltig JSON? (inga avslutande kommatecken, inga kommentarer)
6. ✅ Klient omstartad efter konfigurationsändring?
7. ✅ MCP-server startar manuellt? ()
Problem: Inga verktyg visas i klienten
Symptom
- Claude Desktop / Cursor / Continue visar 0 verktyg
- Ingen 🔌-ikon eller "synapse"-post i MCP-serverlista
Lösningar
1. Starta om klienten helt — Cmd+Q på macOS (inte bara stäng fönstret)
2. Kontrollera sökväg till konfigurationsfil:
- Claude Desktop macOS:
- Claude Desktop Windows:
- Cursor:
- Continue:
3. Validera JSON — klistra in konfiguration i
4. Kontrollera klientloggar för MCP-fel:
- Claude Desktop: (macOS)
- Cursor: View → Output → MCP
5. Kör MCP-server manuellt för att se startfel:
[CODE BLOCK]
Problem: "Mind Key invalid"-fel
Symptom
- Verktyg visas men anrop misslyckas med "401 Unauthorized"
- Fel: "Mind Key fehlt oder ungültig"
Lösningar
1. Verifiera Mind Key-format — börjar med , 40 tecken
2. Testa direkt:
[CODE BLOCK]
3. Kontrollera att miljövariabel är satt — för stdio-transport måste
miljövariabeln vara i MCP-serverkonfigurationen, inte ert shell
4. Hämta en ny Mind Key:
[CODE BLOCK]
Problem: npx hittades inte
Symptom
- Fel: "npx: command not found"
- MCP-server startar inte
Lösningar
1. Installera Node.js 18+:
- macOS: eller ladda ner från
- Linux:
- Windows: ladda ner från
2. Starta om terminal efter installation
3. Verifiera:
Problem: SYNAPSEURL onåbar
Symptom
- MCP-server startar men verktygsanrop time-outar
- Fel: "fetch failed" eller "ECONNREFUSED"
Lösningar
1. Testa anslutning:
[CODE BLOCK]
2. Kontrollera företagsbrandvägg — kan blockera utgående HTTPS
3. Prova alternativ URL:
- Produktion:
- MCP-server:
4. För egenvärd: säkerställ att er Synapse-instans körs och är åtkomlig
Problem: MCP-server kraschar
Symptom
- MCP-server avslutas omedelbart efter start
- Klientloggar visar "MCP server disconnected"
Lösningar
1. Kör manuellt för att se fel:
[CODE BLOCK]
2. Kontrollera portkonflikter — MCP-server använder port 13100 som standard
3. Rensa npx-cache:
[CODE BLOCK]
4. Uppdatera till senaste:
[CODE BLOCK]
Problem: Verktygsanrop returnerar 429
Symptom
- Fel: "Rate limit exceeded"
Lösningar
Detta bör inte hända med MCP (använder header-auth, ingen hastighetsgräns). Om det gör det:
1. Kontrollera om ni använder nånstans — byt till header-auth
2. Verifiera — säkerställ att den pekar på rätt instans
3. Kontakta support om problemet kvarstår
Problem: Verktyg visas men fungerar inte
Symptom
- Verktyg listade i klient
- Att anropa ett verktyg returnerar fel eller inget resultat
Lösningar
1. Kontrollera verktygsnamnet — måste vara exakt (t.ex. , inte )
2. Verifiera argument — kontrollera verktygets indataschema
3. Testa via direkt API:
[CODE BLOCK]
4. Kontrollera Synapse-hälsa:
[CODE BLOCK]
Få hjälp
Om inget av ovanstående löser ert problem:
1. Kontrollera befintliga ärenden:
2. Öppna ett nytt ärende med:
- MCP-serverversion ()
- Klientnamn och version
- Operativsystem
- Relevanta loggutdrag
- Steg för att reproducera
Nästa steg
- Claude Desktop-konfiguration
- Claude Code-konfiguration
- API-fel
────────────────────────────────────────────────────────────
# Vad är MCP?
SUMMARY: Model Context Protocol låter LLM:er anropa externa verktyg. Synapse exponerar 79 verktyg via officiell MCP-server.
KEY CONTEXT:
MCP = Model Context Protocol (Anthropic, 2024). Open standard for LLM-tool integration.
Synapse has official MCP server: synapse-mcp-api (npm package, npx -y synapse-mcp-api@latest)
79 tools exposed: 22 memory, 7 chat, 8 scheduler, 4 tasks, 5 scripts, 9 computers, 4 push, 5 user, 3 utility
3 transports: stdio (local), HTTP/SSE (remote), WebSocket (mobile)
Supported clients: Claude Desktop, Claude Code, Cursor, Continue, Cline, any MCP-compatible client
Tool Profiles (v1.4.0): minimal (8 tools), standard (25), full (119) — controlled via MCP_PROFILE env or Mcp-Tool-Profile header
Vad är MCP?
Model Context Protocol (MCP) är en öppen standard av Anthropic (2024) som
låter LLM:er anropa externa verktyg på ett strukturerat sätt. Istället för att
klistra in API-dokumentation i prompten registrerar ni verktyg hos MCP-servern,
och LLM:en anropar dem vid behov — som funktionsanrop, men standardiserat och
klientoberoende.
Synapse MCP-server
Synapse levererar en officiell MCP-server ( på npm) som
exponerar 79 verktyg som täcker alla Synapse-funktioner:
| Kategori | Verktyg | Antal |
|----------|-------|-------|
| Memory | recall, list, store, search, semantic-search, update, delete, bulk-delete, stats, unverified, contradictions, audit, related, by-tag, diff, expiring, health, sync, embed-batch, verify, unverify, mind-export | 22 |
| Chat | poll, reply, status, history, unread, send, upload | 7 |
| Scheduler | cronlist, croncreate, crondelete, crontoggle, varlist, varget, varset, vardelete | 8 |
| Tasks | tasklist, taskget, taskcreate, taskupdate | 4 |
| Scripts | scriptlist, scriptget, scriptinfo, scriptstore, scriptdelete | 5 |
| Computers | computerlist, computerget, installcode, screenshot, commandqueue, commandstatus, commandslist, disable, delete | 9 |
| Push | vapidpublickey, subscribe, unsubscribe, test | 4 |
| User/Mind | register, login, mindslist, mindcreate, minddelete | 5 |
| Utility | time, calc, random | 3 |
| Visualization | graph, tags, compact | 3 |
| Sharing | share, list, revoke | 3 |
| Webhooks | register, list, get, update, delete | 5 |
| Browser | new, navigate, click, type, screenshot, close | 6 |
| Totalt | | 79+ |
Hur det fungerar
[CODE BLOCK]
1. Ni konfigurerar er LLM-klient (Claude Desktop, Cursor etc.) för att använda Synapse MCP-server
2. Klienten startar MCP-servern (via )
3. MCP-servern ansluter till Synapse API med er Mind Key
4. LLM:en ser alla 79 verktyg som inbyggda funktioner den kan anropa
5. När LLM:en behöver minna något anropar den — MCP-servern översätter detta till på Synapse
Transporter
Synapse MCP-server stöder tre transporter:
stdio (lokal, rekommenderas för skrivbord)
[CODE BLOCK]
HTTP/SSE (fjärr, multitenant)
Anslut er MCP-klient till:
[CODE BLOCK]
WebSocket (mobil, hög volym)
[CODE BLOCK]
Verktygsprofiler (v1.4.0)
För att minska token-overhead för mindre LLM:er stöder MCP-servern tre
verktygsprofiler:
| Profil | Verktyg | Tokens | Bäst för |
|---------|-------|--------|----------|
| | 8 (sammansatt dispatch) | 500 | Egenvärd LLM:er med ≤8k kontext |
| | 25 (namngivna) | 2 500 | Medelstora LLM:er (Claude Haiku, GPT-3.5) |
| | 119 (alla) | 8 250 | Stora LLM:er (Claude Sonnet/Opus, GPT-4) — standard |
Styr via:
- Miljövariabel:
- Header:
Klienter som stöds
- Claude Desktop — Anthropics skrivbordsapp
- Claude Code — terminalbaserad kodagent
- Cursor — AI-driven IDE
- Continue.dev — öppen källkod AI-kodningsassistent
- Cline — VS Code-tillägg
- Valfri MCP-kompatibel klient
Varför använda MCP istället för direkt API?
| Ansats | Fördelar | Nackdelar |
|----------|------|------|
| Direkt API | Enkelt, inget extra lager | LLM behöver veta URL:er, headers, auth |
| MCP | LLM ser inbyggda verktyg, ingen URL-memorering | Extra MCP-serverprocess |
För de flesta LLM-agent-användningsområden är MCP det bättre valet — LLM:en
behöver inte minnas API-sökvägar eller auth-mönster.
Nästa steg
- Claude Desktop-konfiguration — 2 minuters konfiguration
- Claude Code-konfiguration — terminalintegration
- Anpassad MCP-klient — bygg er egen
## KATEGORI: GUIDER OCH HUR-MAN-GÖR
Steg-för-steg-guider för konkreta scenarier.
────────────────────────────────────────────────────────────
# Automatiserad iOS-apptestning
SUMMARY: Använd Synapse + Computer Control API för att automatisera iOS-apptestning via Simulator.
Automatiserad iOS-apptestning
Kombinera Synapses minnessystem med Computer Control API för att bygga
LLM-drivna iOS-apptester. LLM:en minns testscenarier, lär sig av tidigare
fel och anpassar sig till UI-ändringar.
Arkitektur
[CODE BLOCK]
Förutsättningar
- Synapse-konto + Mind Key
- Synapse MCP-server konfigurerad i Claude Desktop
- iOS Simulator med installerad
- Dator registrerad i Synapse (se Computer Control API)
Steg 1: Registrera Simulator-datorn
På den Mac som kör iOS Simulator:
[CODE BLOCK]
Steg 2: Lagra testscenarier i minne
Lagra återanvändbara testscenarier som minnen:
[CODE BLOCK]
Steg 3: LLM-driven testkörning
I Claude Desktop (med Synapse MCP konfigurerad):
[CODE BLOCK]
Claude kommer att:
1. Anropa för att hitta minnet
2. Anropa för att se aktuellt tillstånd
3. Utföra varje steg via (klick, skriv)
4. Verifiera resultat via skärmdumpar
5. Lagra eventuella fel som -minnen
Steg 4: Självläkande tester
När ett test misslyckas, lagra felet och återställningen:
[CODE BLOCK]
Nästa gång LLM:en kör testet återkallar den felet och tillämpar
återställningen automatiskt.
Steg 5: Spårning av testresultat
Spåra testkörningar som uppgifter:
[CODE BLOCK]
Vanliga kommandon
| Åtgärd | Kommando |
|--------|---------|
| Starta Simulator | |
| Skärmdump | (via Synapse MCP) |
| Tryck på (x,y) | |
| Skriv text | |
| Tryck Home | |
Bästa praxis
> [!TIP]
> - Lagra UI-koordinater som minnen — UI ändras, men LLM:en kan lära om
> - Använd tillgänglighetsetiketter — mer stabilt än koordinater
> - Lagra testdata separat — använd variabler för användarnamn, lösenord
> - Kör tester i rent tillstånd — återställ Simulator mellan körningar
> - Logga skärmdumpar för fel — användbart för felsökning
Nästa steg
- Självläkande tester
- Computer Control API
- Minnesbästa praxis
────────────────────────────────────────────────────────────
# Säkerhetskopiering & återställning
SUMMARY: Exportera era minnen för säkerhetskopiering, migrera mellan minds, återställ efter dataförlust.
Säkerhetskopiering & återställning
Synapse tillhandahåller fullständig export/import för minnesbackup, migrering
och katastrofåterställning. Den här guiden täcker de väsentliga åtgärderna.
Export
Fullständig mind-export
Exportera alla minnen i en mind som JSON:
[CODE BLOCK]
Svarsformat:
[CODE BLOCK]
Inkrementell export (Diff)
Exportera endast minnen som ändrats sedan en tidsstämpel:
[CODE BLOCK]
Svar:
[CODE BLOCK]
Automatiserade säkerhetskopior
Schemalägg dagliga säkerhetskopior via cron:
[CODE BLOCK]
> [!NOTE]
> Cron-endpoint tar emot svaret men lagrar det inte. För riktiga
> säkerhetskopior, peka cronen mot er egen backupserver som sparar svaret.
Bättre: Externt säkerhetskopieringsskript
[CODE BLOCK]
Lägg till i crontab:
[CODE BLOCK]
Återställning
Återställ till samma mind
[CODE BLOCK]
Återställ till ny mind
[CODE BLOCK]
Python-återställningsskript
[CODE BLOCK]
Migrering mellan minds
[CODE BLOCK]
Säkerhetskopiera annan data
Glöm inte att säkerhetskopiera:
| Datatyp | Endpoint |
|-----------|----------|
| Minnen | |
| Uppgifter | |
| Skript | |
| Webhooks | |
| Cron-jobb | |
| Variabler | |
| Chatthistorik | |
Verifiering
Efter återställning, verifiera:
[CODE BLOCK]
Bästa praxis
> [!TIP]
> - Säkerhetskopiera dagligen — automatisera med cron
> - Testa återställningar — en säkerhetskopia ni inte kan återställa är värdelös
> - Behåll flera versioner — minst 30 dagar
> - Lagra externt — S3, Backblaze B2 etc.
> - Kryptera känsliga säkerhetskopior — minnen kan innehålla personuppgifter
> - Dokumentera återställningsprocessen — ni kommer att glömma den tills ni behöver den
Nästa steg
- Memory API
- Cron & Scheduler — för automatiserade säkerhetskopior
────────────────────────────────────────────────────────────
# Minnesbästa praxis
SUMMARY: Hur man strukturerar minnen för effektiv återkallning — kategorier, nycklar, taggar, prioriteringar.
Minnesbästa praxis
Hur ni strukturerar minnen avgör hur användbara de är. Den här guiden täcker
mönster för kategorisering, taggning och prioritering av minnen så att LLM:en
kan återkalla rätt information vid rätt tidpunkt.
Kategorier: välj den mest specifika
| Kategori | Använd för | Exempel |
|----------|---------|---------|
| | Användarnamn, roll, kontaktinfo | |
| | Tycker om, ogillar, arbetsstil | |
| | Verifierbara fakta | |
| | Projektstatus, beslut | |
| | Användarens färdigheter | |
| | Tidigare fel att undvika | |
| | Sessionsrelevant kontext | |
| | Diverse anteckningar | |
> [!TIP]
> Vid tveksamhet, använd för verifierbar info och för allt annat.
> Överkategorisera inte — bättre med en tydlig än en förvirrande .
Nycklar: meningsfulla identifierare
Fältet är minnets identifierare. Använd meningsfulla, stabila nycklar:
Bra nycklar:
-
-
-
-
Dåliga nycklar:
- (inte meningsfull)
- (inte beskrivande)
- (datum hjälper inte återkallning)
Namngivningskonventioner för nycklar
- (gemener med understreck)
- Prefixa med kategori: , ,
- Använd beskrivande substantiv, inte verb
- Håll under 50 tecken
Taggar: för sökning och filtrering
Taggar möjliggör snabb filtrering och sökning. Lägg till 2–5 taggar per minne:
[CODE BLOCK]
Taggmönster
- Projektnamn: , ,
- Ämnen: , , ,
- Status: , ,
- Prioriteringsindikatorer: ,
> [!NOTE]
> Taggar är skiftesokänsliga. Använd gemener för konsekvens.
Prioriteringar: var realistisk
| Prioritering | Använd för | % av minnen |
|----------|---------|---------------|
| | Användaridentitet, juridisk info, oåterkalleliga beslut | 5% |
| | Aktiva projekt, viktiga inställningar | 20% |
| | De flesta fakta, anteckningar, kontext | 65% |
| | Efemärt, trevligt att veta | 10% |
> [!WARNING]
> Markera inte allt som . Om allt är kritiskt är inget det.
> Reservera för saker som skulle orsaka verklig skada om de glöms.
När man ska lagra vs inte lagra
Lagra alltid
- Användaridentitet (namn, e-post, roll)
- Långsiktiga inställningar
- Projektbeslut och motivering
- Tidigare misstag och lärdomar
- Åtaganden gentemot användaren
Lagra inte
- Övergående tillstånd (använd variabler istället)
- Ordagrant konversationshistorik (chattsystemet hanterar detta)
- Känslig data (lösenord, API-nycklar)
- Lätt härledbara fakta (aktuellt datum, filinnehåll)
- Efemär kontext (använd -kategori med låg prioritet)
Uppdatera minnen
POST med samma + uppdaterar det befintliga minnet:
[CODE BLOCK]
> [!TIP]
> Använd stabila nycklar så att ni kan uppdatera utan att skapa dubbletter.
> LLM:en bör åter-POSTa samma nyckel när information ändras, inte skapa nya minnen.
Minneslivscykel
[CODE BLOCK]
- Create: POST /memory med full kontext
- Active: Återkalla ofta, uppdatera vid behov
- Stale: Fortfarande relevant men inte aktivt använd (lägre prioritet?)
- Archive: Sätt prioritet till , behåll för historisk referens
- Delete: DELETE /memory/:id när inte längre relevant
Periodisk rensning
[CODE BLOCK]
Mönster: Minnesarv
För hierarkisk kontext (projekt → delprojekt → uppgift):
[CODE BLOCK]
LLM:en kan sedan söka för att hitta alla relaterade minnen.
Mönster: Beslutslogg
Lagra beslut med motivering så att LLM:en inte återupprättar dem:
[CODE BLOCK]
Mönster: Misstag undvikande
Lagra misstag med specifika undvikandeinstruktioner:
[CODE BLOCK]
Antimönster att undvika
> [!WARNING]
> - Lagra konversationsloggar — chattsystemet hanterar detta
> - Lagra hela filer — använd skriptlager eller extern lagring
> - Lagra efemärt tillstånd — använd variabler
> - Lagra hemligheter — använd miljövariabler
> - Duplicera minnen — använd stabila nycklar
> - Övertagga — 2–5 taggar per minne är idealiskt
> - Allt är kritiskt — var realistisk med prioriteringar
Nästa steg
- Memory API
- Beständig LLM-agent
- Minnes taggningsstrategi
────────────────────────────────────────────────────────────
# Multi-agent-koordinering
SUMMARY: Koordinera flera LLM-agenter med delade Synapse-minds, uppgifter och chatt.
Multi-agent-koordinering
När ni har flera LLM-agenter som arbetar med relaterade uppgifter tillhandahåller
Synapse koordinationslagret — delat minne, uppgiftstilldelning och asynkron chatt.
Mönster
Mönster 1: Delad mind (enskild sanningskälla)
Alla agenter delar en Mind Key. De läser/skriver till samma minneslager.
[CODE BLOCK]
Användningsområde: Litet team av agenter som arbetar med ett projekt.
Konfiguration:
[CODE BLOCK]
Koordinering via uppgifter:
[CODE BLOCK]
Mönster 2: Specialiserade minds (isolerade kontexter)
Varje agent har sin egen mind. De kommunicerar via en delad
"koordinations"-mind.
[CODE BLOCK]
Användningsområde: Agenter med olika specialiteter (kodning, granskning, driftsättning).
Konfiguration:
[CODE BLOCK]
Koordinering via delad mind:
[CODE BLOCK]
Mönster 3: Hub-and-spoke (orchestrator)
En central orchestrator-agent tilldelar uppgifter till arbetsagenter.
[CODE BLOCK]
Användningsområde: Komplexa arbetsflöden med parallellt arbete.
Implementering:
[CODE BLOCK]
Koordinering via chatt
Agenter kan kommunicera via chattsystemet:
[CODE BLOCK]
> [!NOTE]
> Chattmeddelanden är rolltaggade. Sätt role=agent för agent-till-agent-meddelanden,
> role=human för människa-till-agent.
Koordinering via variabler
Använd variabler för lättviktig koordinering (lås, flaggor):
[CODE BLOCK]
Bästa praxis
> [!TIP]
> - Använd separata minds för separata ärenden — blanda inte kodar- och granskarminne
> - Tagga agenter i chatt — för tydlig adressering
> - Använd uppgifter för arbetstilldelning — inte chatt (chatt är för diskussion)
> - Implementera idempotens — agenter kan försöka om misslyckade åtgärder
> - Logga allt — lagra beslut i minne för granskbarhet
Nästa steg
- Beständig LLM-agent
- LLM-kokbok
- Webhook-automatisering
────────────────────────────────────────────────────────────
# Bygg en beständig LLM-agent
SUMMARY: Steg-för-steg-guide för att bygga en LLM-agent som minns över sessioner med Synapse.
Översikt
Den här guiden går igenom att bygga en LLM-agent som persistens kontext över
sessioner med Synapse. I slutet kommer er agent att:
- Återkalla tidigare kontext vid sessionsstart
- Lagra nya lärdomar när de sker
- Spåra uppgifter i flera steg över sessioner
- Kommunicera med människor via asynkron chatt
Arkitektur
[CODE BLOCK]
Steg 1: Sätt upp Mind Key
[CODE BLOCK]
Steg 2: Sessionsstart-protokoll
I början av varje session, återkalla alla minnen:
[CODE BLOCK]
Steg 3: Lagra nya lärdomar
När agenten lär sig något värt att komma ihåg:
[CODE BLOCK]
Steg 4: Uppgiftshantering
Spåra arbete i flera steg över sessioner:
[CODE BLOCK]
Steg 5: Asynkron chatt med människor
Polla efter meddelanden mellan verktygsanrop:
[CODE BLOCK]
Steg 6: Sessionsavsluts-protokoll
Vid sessionsavslut, lagra slutgiltig kontext:
[CODE BLOCK]
Komplett mönster
[CODE BLOCK]
Bästa praxis
> [!TIP]
>
> - Återkalla alltid först — starta aldrig arbete utan att ladda kontext
> - Lagra proaktivt — vänta inte till sessionsavslut
> - Använd meningsfulla nycklar — , , inte
> - Tagga allt — taggar driver sökning och filtrering
> - Sätt realistiska prioriteringar — inte allt är
Nästa steg
- LLM-kokbok — praktiska mönster
- Minnesbästa praxis
- Multi-agent-koordinering
────────────────────────────────────────────────────────────
# Självläkande testpipelines
SUMMARY: Bygg testpipelines som lär sig av fel och anpassar sig automatiskt med Synapse-minne.
Självläkande testpipelines
Traditionella testsviter går sönder när UI ändras. Självläkande tester använder
Synapse-minne för att lära sig av tidigare fel och anpassa sig — vilket minskar
ostabila tester och underhållsbörda.
Koncept
[CODE BLOCK]
1. Test körs
2. Om det misslyckas, lagra felet (vad som gick fel, varför, hur man fixar)
3. Nästa körning: återkalla relevanta fel innan körning
4. Tillämpa kända fixar automatiskt
Implementering
Steg 1: Test-omslag
Omslut varje test med minnesåterkallning/lagring:
[CODE BLOCK]
Steg 2: Adaptiv testlogik
Inuti testet, kontrollera kända fel och tillämpa fixar:
[CODE BLOCK]
Steg 3: Återställningsstrategier
Lagra återställningsstrategier som minnen:
[CODE BLOCK]
Steg 4: CI-integration
[CODE BLOCK]
Steg 5: Instrumentpanel för felanalys
[CODE BLOCK]
Bästa praxis
> [!TIP]
> - Lagra tracebacks — de innehåller den exakta raden som misslyckades
> - Tagga efter testnamn — möjliggör snabb filtrering
> - Använd -kategori — separerar från vanliga minnen
> - Sätt prioritet — fel bör aldrig glömmas
> - Periodisk rensning — ta bort minnen för lösta problem
> - Lagra inte känslig data — referenser, personuppgifter
Vanliga felmönster att lagra
| Feltyp | Vad som ska lagras |
|--------------|---------------|
| Element hittades inte | Selector som provades, sidtillstånd, skärmdump |
| Timeout | Väntetid, vad som väntades på |
| Assertion misslyckades | Förväntat vs faktiskt värde |
| Nätverksfel | URL, statuskod, svarskropp |
| Nekad behörighet | Nödvändig behörighet, aktuell användarroll |
Nästa steg
- Automatiserad iOS-testning
- Minnesbästa praxis
- Kokbok för felåterställning
────────────────────────────────────────────────────────────
# Webhook-automatisering
SUMMARY: Utlös externa system när minnen ändras — synkronisera, avisera, automatisera.
Webhook-automatisering
Webhooks låter er utlösa externa system när Synapse-händelser utlöses. Den här
guiden täcker vanliga automationsmönster.
Vanliga mönster
Mönster 1: Avisera vid kritiskt minne
Skicka ett Slack-meddelande när ett kritiskt minne lagras:
[CODE BLOCK]
Registrera webhooken:
[CODE BLOCK]
Mönster 2: Synkronisera till externt system
Synkronisera minnen till Notion, Obsidian eller valfritt externt KB:
[CODE BLOCK]
Mönster 3: Utlös CI/CD
Utlös en driftsättning när ett "release"-minne lagras:
[CODE BLOCK]
Mönster 4: Väck agent vid mänskligt meddelande
Utlös en LLM-agentkörning när en människa skickar ett chattmeddelande:
[CODE BLOCK]
Mönster 5: Aggregera mätvärden
Spåra minnestillväxt, chattaktivitet, uppgiftsslutförande:
[CODE BLOCK]
Signaturverifiering
Verifiera alltid webhook-signaturer för att förhindra förfalskning:
[CODE BLOCK]
Logik för omprövning
Synapse försöker om misslyckade webhooks med exponentiell backoff. Er hanterare
bör:
1. Returnera 200 snabbt — gör inte tungt arbete synkront
2. Köa arbete — använd ett bakgrundsjobb-system
3. Vara idempotent — samma händelse kan levereras två gånger
[CODE BLOCK]
Felsökning av webhooks
Kontrollera leveranshistorik
Webhook-leveranser loggas. Kontrollera er webhooks senaste leveranser:
[CODE BLOCK]
Testa webhook manuellt
[CODE BLOCK]
Vanliga problem
| Problem | Lösning |
|-------|-----|
| 4xx-svar | Kontrollera att er hanterare returnerar 200 |
| 5xx-svar | Serverfel — kontrollera er app-logg |
| Timeout | Returnera 200 snabbt, köa arbete asynkront |
| Dubbletta leveranser | Gör hanteraren idempotent |
| Signaturfel | Verifiera att secret är korrekt |
Bästa praxis
> [!TIP]
> - Verifiera alltid signaturer — hoppa aldrig över detta
> - Returnera 200 snabbt — blockera inte Synapse
> - Vara idempotent — hantera dubbletta leveranser
> - Använd specifika händelser — inte
> - Övervaka leveransfel — sätt upp avisering
Nästa steg
- Webhooks API
- Cron & Scheduler
- Beständig LLM-agent
## KATEGORI: KONCEPT
Arkitektur och koncept bakom Synapse.
────────────────────────────────────────────────────────────
# Synapse-arkitektur
SUMMARY: Hur Synapse är byggt — Fastify, PostgreSQL, FTS5, inbäddningar, MCP-server.
Synapse-arkitektur
Synapse är ett multitenant-minnes-API byggt på Fastify, PostgreSQL med FTS5 och
en valfri inbäddningstjänst för semantisk sökning.
Arkitektur på hög nivå
[CODE BLOCK]
Kärnkomponenter
1. Synapse API (Fastify)
Huvud-HTTP-servern. Hanterar:
- REST-endpoints (, , etc.)
- Autentisering (Mind Key för agenter, JWT för människor)
- Hastighetsbegränsning (endast -auth)
- Statisk filservering (webbgränssnitt på , etc.)
- Webhook-utsändning
Byggd med Fastify 5 för prestanda. Körs på port 12800 i produktion.
2. PostgreSQL med FTS5
Det primära datalagret. Använder PostgreSQL med FTS5-tillägget för fulltextssök.
Nyckeltabeller:
| Tabell | Syfte |
|-------|---------|
| | Användarkonton |
| | Mind-omfattningar (varje har en Mind Key) |
| | Minnesposter med FTS5 virtuell tabell |
| | Uppgiftshantering |
| | Chatthistorik |
| | Beständiga skript |
| | Webhook-registreringar |
| | Schemalagda uppgifter |
| | Nyckel-värde-lager |
| | Granskningsspår |
FTS5 möjliggör fulltextssök under en millisekund över allt minnesinnehåll.
Se FTS5-sökning för detaljer.
3. Inbäddningstjänst (valfri)
För semantisk sökning genererar Synapse vektorinbäddningar av minnesinnehåll.
Dessa lagras tillsammans med minnen och används för likhetssökning.
- Leverantör: konfigurerbar (OpenAI, lokal modell etc.)
- Lagras som -kolumn i -tabellen
- Används av -endpoint
- Se Semantisk sökning
4. MCP-server (separat tjänst)
Synapse MCP-server körs som en separat process (port 13100). Den:
- Exponerar 79 verktyg via Model Context Protocol
- Stöder stdio-, HTTP/SSE- och WebSocket-transporter
- Översätter MCP-verktygsanrop till Synapse API-anrop
- Multitenant: en Mind Key per session
5. Browser Proxy (separat tjänst)
För webbläsarautomatisering körs en separat Playwright-baserad tjänst på port
13000. MCP-servern kan anropa denna för -verktyg.
6. SSH Proxy (separat tjänst)
För SSH-baserade fjärrkommandon körs en separat tjänst på port 12900.
Multitenant-modell
[CODE BLOCK]
Varje mind är fullständigt isolerad. Mind Keys ger åtkomst till exakt en mind.
JWT:er ger åtkomst till användarkontot (för att hantera minds).
Se Multitenancy för detaljer.
Begärandeflöde
Minneslagringsbegäran
[CODE BLOCK]
Minnessökningsbegäran
[CODE BLOCK]
Driftsättning
Synapse driftsätts som en Docker-container. Se :
[CODE BLOCK]
Prestandaegenskaper
| Åtgärd | Latens | Genomströmning |
|-----------|---------|------------|
| Minneslagring | 5 ms | 1000+ req/s |
| Minnesåterkallning | 20 ms | 500 req/s |
| FTS5-sökning | 10 ms | 800 req/s |
| Semantisk sökning | 50 ms | 200 req/s |
| Chat-poll | 5 ms | 2000 req/s |
Nästa steg
- Minnesmodell
- Multitenancy
- FTS5-sökning
────────────────────────────────────────────────────────────
# FTS5 fulltextssökning
SUMMARY: Hur Synapse använder SQLite FTS5 för fulltextssökning av minnen under en millisekund.
FTS5 fulltextssökning
Synapse använder FTS5 (Full-Text Search 5) för snabb, flexibel minnessökning.
Den här sidan förklarar hur det fungerar och hur man använder det effektivt.
Vad är FTS5?
FTS5 är ett SQLite-tillägg (även tillgängligt i PostgreSQL via tillägg) som
tillhandahåller fulltextssökningsfunktionalitet. Det:
- Indexerar textinnehåll för snabb nyckelordssökning
- Stöder booleska operatorer (AND, OR, NOT)
- Stöder frasmatchning med citattecken
- Stöder prefixmatchning med
- Rankar resultat efter relevans
Synapse använder FTS5 för att indexera allt minnesinnehåll, vilket möjliggör
sökning under en millisekund över tusentals minnen.
Hur Synapse använder FTS5
När ni gör :
1. Minnesinnehåll lagras i -tabellen
2. Innehåll infogas också i FTS5 virtuell tabell
3. FTS5 tokeniserar och indexerar innehållet automatiskt
När ni gör :
1. Synapse tolkar frågan med FTS5-syntax
2. Kör en mot FTS5-indexet
3. Filtrerar efter (klientisolation)
4. Returnerar rankade resultat
Frågesyntax
Enkel nyckelordssökning
[CODE BLOCK]
Returnerar minnen som innehåller "docker".
Flera nyckelord (implicit AND)
[CODE BLOCK]
Returnerar minnen som innehåller BÅDE "docker" OCH "swarm".
Frasmatchning
[CODE BLOCK]
Returnerar minnen som innehåller den exakta frasen "docker swarm".
Prefixmatchning
[CODE BLOCK]
Returnerar minnen som innehåller ord som börjar med "docker" (t.ex. "dockers",
"dockerfile", "dockerize").
Boolesk OR
[CODE BLOCK]
Returnerar minnen som innehåller "docker" ELLER "kubernetes".
Boolesk NOT
[CODE BLOCK]
Returnerar minnen som innehåller "docker" men INTE "swarm".
Gruppering
[CODE BLOCK]
Returnerar minnen som innehåller "docker" eller "kubernetes", men inte "test".
Praktiska exempel
Hitta minnen om ett projekt
[CODE BLOCK]
Hitta exakt fras
[CODE BLOCK]
Uteslut testminnen
[CODE BLOCK]
Hitta efter teknik
[CODE BLOCK]
Rankning
FTS5 rankar resultat efter relevans med BM25-algoritmen. Faktorer:
- Termfrekvens (hur ofta termen förekommer)
- Inverse document frequency (sällsynta termer rankas högre)
- Dokumentlängd (kortare dokument med termen rankas högre)
- Kolumnvikt (title > content)
Resultat returneras i rankningsordning (mest relevant först).
Prestanda
| Åtgärd | Latens |
|-----------|---------|
| Sök 100 minnen | < 5 ms |
| Sök 1 000 minnen | < 10 ms |
| Sök 10 000 minnen | < 25 ms |
| Sök 100 000 minnen | < 100 ms |
FTS5 är högt optimerat för läsintensiva arbetsbelastningar.
Begränsningar
Stamning
FTS5 gör inte stamning som standard. "running" och "run" är olika termer.
Lösning: Använd prefixmatchning:
Tolerans mot felstavning
FTS5 stöder inte oskarp matchning. En felstavning returnerar inga resultat.
Lösning: Använd semantisk sökning () för
begreppsmatchning.
Stopword
Vanliga ord (the, a, an, is) indexeras men kanske inte är användbara för
sökning. FTS5 hanterar detta automatiskt.
FTS5 vs semantisk sökning
| Aspekt | FTS5 | Semantisk sökning |
|--------|------|-----------------|
| Hastighet | Under en millisekund | 50–100 ms |
| Matchning | Exakta nyckelord | Begreppslig |
| Tolerans mot felstavning | Ingen | Någon |
| Stamning | Ingen | Implicit |
| Kräver inbäddningar | Nej | Ja |
| Bäst för | Specifika termer | Begrepp |
Använd FTS5 när ni känner till nyckelorden. Använd semantisk sökning när ni
vill ha "minnen om X" där X beskrivs på ett annat sätt.
Bästa praxis
> [!TIP]
> - Använd specifika termer — "docker swarm" slår "container orchestration"
> - Citera fraser — säkerställer frasmatchning
> - Använd prefix för variationer — fångar "deploy", "deployment", "deploying"
> - Uteslut brus — filtrerar bort testminnen
> - Kombinera med taggar — snävar in resultatet
Nästa steg
- Semantisk sökning
- Memory API
- Minnesbästa praxis
────────────────────────────────────────────────────────────
# Minnesmodellen
SUMMARY: Hur minnen är strukturerade — kategorier, nycklar, taggar, prioriteringar, källor, verifiering.
Minnesmodellen
Synapses minnesmodell är utformad för LLM-agenter — tillräckligt strukturerad
för pålitlig återkallning, tillräckligt flexibel för alla domäner.
Minnesanatomi
[CODE BLOCK]
Fält
| Fält | Typ | Obligatorisk | Beskrivning |
|-------|------|----------|-------------|
| | sträng | auto | Unikt ID (memxxx) |
| | enum | ✅ | En av 8 kategorier |
| | sträng | ✅ | Stabil identifierare (används för uppdateringar) |
| | sträng | ✅ | Minnesinnehållet (valfri text) |
| | sträng[] | – | För sökning och filtrering |
| | enum | – | low, normal, high, critical (standard: normal) |
| | enum | auto | user, agent (vem som lagrade det) |
| | bool | auto | Har en människa verifierat detta? |
| | flyttal | – | 0.0 till 1.0 (standard: 1.0 för user, 0.7 för agent) |
| | tidsstämpel | – | När minnet ska glömmas |
| | sträng | auto | Vilken mind som äger detta |
| | tidsstämpel | auto | Först lagrad |
| | tidsstämpel | auto | Senast ändrad |
Kategorier
Åtta kategorier täcker vanliga användningsområden för LLM-agenter:
| Kategori | Syfte | Exempel på innehåll |
|----------|---------|-----------------|
| | Vem användaren är | "User is Michael Schäfer, software engineer in Berlin" |
| | Användarinställningar | "Prefers concise technical responses" |
| | Verifierbara fakta | "Office is in Berlin, timezone Europe/Berlin" |
| | Projektstatus | "Synapse v1.5.0 deployed, working on v1.6.0 docs" |
| | Användarens färdigheter | "Advanced Python, 10+ years" |
| | Tidigare fel | "Forgot to bump npm version — CI failed" |
| | Sessionskontext | "Currently reviewing PR #42" |
| | Diverse anteckningar | "Try Redis for caching next sprint" |
Nycklar: stabila identifierare
Fältet är kritiskt — det är så ni uppdaterar minnen utan att skapa
dubbletter.
[CODE BLOCK]
Nyckelregler:
- Måste vara unik inom (category, mind)
- Använd
- Prefixa med kategori för tydlighet: ,
- Håll stabil — ändra inte nycklar efter skapandet
Taggar: för sökning
Taggar möjliggör snabb filtrering och sökning:
[CODE BLOCK]
Bästa praxis för taggar:
- 2–5 taggar per minne (överätta inte)
- Gemener för konsekvens
- Använd projektnamn, ämnen, tekniker
- Taggar är skiftesokänsliga
Prioriteringsnivåer
| Prioritering | När den ska användas | Återkallningsbeteende |
|----------|-------------|-----------------|
| | Identitet, juridik, oåterkalleligt | Alltid högst upp i återkallning |
| | Aktiva projekt, nyckelinställningar | Framträdande i återkallning |
| | De flesta minnen (standard) | Standardordning för återkallning |
| | Efemärt, trevligt att veta | Kan sammanfattas |
sorterar efter prioritet (kritisk först), sedan efter aktualitet.
Källa: användare vs agent
Minnen taggas med :
- — lagrad av en människa (via JWT eller mänskligt gränssnitt)
- — lagrad av en LLM-agent (via Mind Key)
Detta påverkar:
- Verifiering: -minnen verifieras automatiskt, -minnen inte
- Konfidens: standard 1.0, 0.7
- Återkallning: markerar overifierade minnen med "(unverified)"
> [!NOTE]
> Behandla -källade minnen med lämplig skepsis. De kan vara härledda
> eller antagna snarare än direkt angivna av användaren.
Verifiering
Flaggan indikerar att en människa har bekräftat minnet:
- -minnen: auto-verifierade ()
- -minnen: standard overifierade ()
Verifiera minnen via:
[CODE BLOCK]
> [!NOTE]
> Verifiering kräver JWT (mänsklig autentisering), inte Mind Key
> (agent-autentisering). Detta säkerställer att endast människor kan markera
> minnen som verifierade.
Konfidens
Fältet (0.0 till 1.0) indikerar hur pålitligt minnet är:
- 1.0 — direkt angivet av användare
- 0.7 — härlett av agent
- 0.5 — osäkert, behöver verifiering
- 0.0 — uttryckligen tvivelaktigt
Sätt konfidens vid lagring:
[CODE BLOCK]
Utgång
Sätt för tidskänsliga minnen:
[CODE BLOCK]
Utgångna minnen returneras inte av (men finns fortfarande i DB).
Använd för att se minnen som löper ut snart.
Minneslivscykel
[CODE BLOCK]
Återkallningsbeteende
returnerar en oformaterad textsammanfattning optimerad
för LLM-kontext:
[CODE BLOCK]
- Sorterat efter prioritet (kritisk → låg), sedan efter aktualitet
- Overifierade minnen markerade med
- Taggar inkluderade för kontext
- Oformaterad text (ingen JSON-tolkning behövs)
Nästa steg
- Memory API
- Minnesbästa praxis
- FTS5-sökning
────────────────────────────────────────────────────────────
# Multitenancy & isolation
SUMMARY: Hur Synapse isolerar data mellan användare och minds — säkerhetsgränser förklarade.
Multitenancy & isolation
Synapse är multitenant: flera användare, var och en med flera minds, fullständigt
isolerade från varandra. Den här sidan förklarar isolationsmodellen.
Klienthierarki
[CODE BLOCK]
Isolationsnivåer
Nivå 1: Användarisolation
Varje användarkonto är isolerat. Alice kan inte:
- Se Bobs minds
- Komma åt Bobs minnen (även med sin JWT)
- Lista Bobs kontoinformation
Upprätthålls av: -kolumn på alla tabeller, JWT innehåller ,
alla frågor filtrerar efter .
Nivå 2: Mind-isolation
Inom en användare är varje mind isolerad. Mind A kan inte:
- Se Mind B:s minnen
- Komma åt Mind B:s uppgifter, chatt, skript
Upprätthålls av: -kolumn på alla datatabeller, Mind Key innehåller
, alla frågor filtrerar efter .
> [!CRITICAL]
> Mind Key-isolation är den primära säkerhetsgränsen. En läckt Mind Key ger
> full åtkomst till den mindens data — men ENDAST den minden.
Autentiseringstoken
| Token | Omfattning | Vad den kan komma åt |
|-------|-------|-------------------|
| Mind Key | Enskild mind | Endast den mindens data |
| JWT | Användarkonto | Kontohantering (skapa/lista/ta bort minds) |
| Computer Token | Enskild dator | Den datorns kommandon |
Åtkomst över mind-gränser
Inom samma användare
Användaren kan komma åt alla sina minds via JWT (t.ex. listar
alla). Men för att läsa/skriva minnesdata behöver de specifik Mind Key.
Mellan användare
Användare kan inte komma åt varandras data — OM INTE de uttryckligen delar en
mind via Sharing API:
[CODE BLOCK]
Efter delning kan Bob komma åt Mind A via sin JWT (skrivskyddad om ).
Säkerhetsgränser
[CODE BLOCK]
Vanliga multitenancy-mönster
Mönster 1: Enskild användare, enskild mind
Vanligast för enskilda LLM-agentanvändare.
- 1 användarkonto
- 1 mind
- 1 Mind Key
- Alla minnen i en omfattning
Mönster 2: Enskild användare, flera minds
För användare med flera kontexter (arbete, personligt, projekt).
- 1 användarkonto
- N minds (t.ex. "work", "personal", "project-x")
- N Mind Keys
- Varje LLM-session använder en Mind Key
Mönster 3: Team-delad mind
För team som samarbetar kring ett projekt.
- 1 användare skapar minden (får Mind Key)
- Skaparen delar med teammedlemmar via JWT
- Alla teammedlemmar kommer åt via JWT (eller delad Mind Key)
> [!WARNING]
> Att dela en Mind Key ger full läs/skriv-åtkomst. För teamsamarbete,
> föredra Sharing API (JWT-baserad) framom att dela Mind Keys direkt.
Mönster 4: SaaS-leverantör
För appar som bäddar in Synapse som sitt minneslager.
- Varje kund = 1 användarkonto
- Varje kundprojekt = 1 mind
- Appen lagrar Mind Keys per kund/projekt
- Full isolation mellan kunder
Verifiering av isolation
Test: Mind Key kan inte komma åt andra minds
[CODE BLOCK]
Test: JWT kan inte läsa minnesdata direkt
[CODE BLOCK]
Bästa praxis
> [!TIP]
> - Använd en mind per projekt/kontext — isolation är er vän
> - Dela aldrig Mind Keys — använd Sharing API istället
> - Rotera Mind Keys om komprometterade (ta bort mind, skapa ny)
> - Granska delade minds — se över regelbundet
> - Använd JWT för mänskligt gränssnitt — exponera aldrig Mind Keys för slutanvändare
Nästa steg
- Autentisering
- Mind Key vs JWT
- Arkitektur
────────────────────────────────────────────────────────────
# Semantisk sökning (inbäddningar)
SUMMARY: Begreppslig minnessökning med vektorinbäddningar — hitta efter betydelse, inte bara nyckelord.
Semantisk sökning (inbäddningar)
Synapse stöder semantisk sökning med vektorinbäddningar. Till skillnad från FTS5
(nyckelordsmatchning) hittar semantisk sökning minnen efter betydelse — även
om inga nyckelord matchar.
Hur det fungerar
[CODE BLOCK]
Vad är inbäddningar?
Inbäddningar är numeriska vektorrepresentationer av text. Text med liknande
betydelse har liknande vektorer. Synapse genererar en vektor (t.ex. 1536
dimensioner) för varje minnes innehåll.
Cosine similarity
För att hitta semantiskt liknande minnen beräknar Synapse cosinuslikheten
mellan frågevektorn och varje minnesvektor. Högre likhet = mer relevant.
När semantisk sökning ska användas
Använd semantisk sökning när:
- Ni vill ha "minnen om X" där X beskrivs annorlunda än lagrat
- FTS5 returnerar inga resultat (ingen nyckelordsmatchning)
- Ni vill ha begreppslig gruppering (t.ex. alla "deployment"-minnen, även om vissa säger "release")
- Frågan är en fråga: "hur hanterar vi autentisering?"
Använd FTS5 när:
- Ni känner till exakta nyckelord
- Ni behöver boolesk logik (AND, OR, NOT)
- Ni behöver svar under en millisekund
- Ni vill ha frasmatchning
Endpoint
GET /memory/semantic-search
[CODE BLOCK]
Svar:
[CODE BLOCK]
Exempel
Hitta driftsättningsminnen
[CODE BLOCK]
Returnerar minnen om "deployment", "release", "publishing", "rolling out" etc.
Hitta autentiseringsmönster
[CODE BLOCK]
Returnerar minnen om inloggning, auth, JWT, sessionshantering, OAuth etc.
Hitta liknande minnen
[CODE BLOCK]
Använder semantisk likhet (via gemensamma taggar OCH inbäddningsvektorer).
Inbäddningsgenerering
När genereras inbäddningar?
- Vid minneslagring — om inbäddningstjänst är konfigurerad genereras inbäddning synkront
- Batchgenerering — genererar inbäddningar för minnen som saknar dem
- Asynkrona uppdateringar — när innehåll uppdateras regenereras inbäddningen
Inbäddningsleverantörer
Synapse stöder konfigurerbara inbäddningsleverantörer:
- OpenAI (, )
- Lokala modeller (via Ollama eller liknande)
- Anpassade (implementera inbäddningsgränssnittet)
Konfigurera via miljövariabler:
[CODE BLOCK]
Batchgenerering
För minds med många minnen som saknar inbäddningar:
[CODE BLOCK]
Prestanda
| Åtgärd | Latens |
|-----------|---------|
| Generera inbäddning (OpenAI) | 100–200 ms |
| Semantisk sökning (1k minnen) | 50–100 ms |
| Semantisk sökning (10k minnen) | 200–500 ms |
| Batchgenerering (100 minnen) | 10–20 s |
> [!NOTE]
> Semantisk sökning är långsammare än FTS5 på grund av vektorberäkning.
> Använd FTS5 för kända nyckelord, semantisk för begreppsliga frågor.
Begränsningar
Kostnad för inbäddningar
Om ni använder OpenAI kostar generering av inbäddningar pengar ($0,02 per 1M
tokens för text-embedding-3-small). För 10 000 minnen med i snitt 100 tokens
var blir det $0,02 — försumbart.
Kallstart
Minnen som lagrats innan inbäddningar konfigurerades kommer inte att ha
inbäddningar. Kör för att fylla i.
Leverantörsberoende
Om inbäddningsleverantören är nere misslyckas semantisk sökning graciöst
(returnerar tomma resultat eller fel). FTS5 fungerar fortfarande.
När inbäddningar inte är tillgängliga
Om inbäddningstjänst inte är konfigurerad:
- returnerar 503 Service Unavailable
- fungerar fortfarande (bara ingen inbäddning genererad)
- FTS5-sökning fungerar fortfarande
Bästa praxis
> [!TIP]
> - Använd semantisk för begreppsliga frågor — "hur hanterar vi X?"
> - Använd FTS5 för specifika termer — "docker swarm"
> - Fyll i inbäddningar regelbundet —
> - Övervaka leverantörshälsa — semantisk sökning beror på den
> - Kombinera med taggar — semantisk + taggfilter snävar in resultatet
Nästa steg
- FTS5-sökning
- Memory API
- Arkitektur
## KATEGORI: LLM-KOKBOK
Recept och mönster för LLM-agenter.
────────────────────────────────────────────────────────────
# Chattpollningsmönster
SUMMARY: Hur man pollar efter mänskliga meddelanden mellan verktygsanrop utan att blockera arbetsflödet.
Chattpollningsmönster
Chattsystemet är asynkront — människor kan lämna meddelanden medan ni arbetar.
Detta mönster visar hur man pollar efter meddelanden utan att blockera
arbetsflödet.
Mönstret
[CODE BLOCK]
Polla mellan verktygsanrop, inte i en tight loop.
Varför polla mellan verktygsanrop?
- Blockera inte — pollning i en tight loop slösar API-anrop
- Missa inte meddelanden — för sällan pollning innebär långsamma svar
- Sweet spot — polla var 30–60 sekund, eller efter varje verktygsanrop
Implementering
Grundläggande pollning
[CODE BLOCK]
Mönster 1: Polla efter varje verktygsanrop
[CODE BLOCK]
Mönster 2: Tidsbaserad pollning
[CODE BLOCK]
Mönster 3: Händelsestyrd (med webhooks)
För realtidsavisering, registrera en webhook:
[CODE BLOCK]
Sedan kan er webhook-hanterare väcka agenten:
[CODE BLOCK]
Meddelandehanteringsmönster
Mönster: Bekräfta sedan bearbeta
[CODE BLOCK]
Mönster: Köa för batchbearbetning
[CODE BLOCK]
Mönster: Prioritetsstyrning
[CODE BLOCK]
Pollningsfrekvens
| Användningsområde | Frekvens |
|----------|-----------|
| Interaktiv agent (människa väntar) | Var 5–10 sekund |
| Bakgrundsagent | Var 30–60 sekund |
| Batchbearbetning | Var 5:e minut |
| Webhook-utlöst | Polla inte — använd webhooks |
> [!WARNING]
> Pollning mer än en gång per 5 sekunder slösar API-anrop. Endpointen
> returnerar omedelbart om meddelanden väntar, så det finns ingen
> fördel med snabbare pollning.
Multi-agent-chatt
För agent-till-agent-kommunikation:
[CODE BLOCK]
Bästa praxis
> [!TIP]
> - Polla mellan verktygsanrop — inte i en tight loop
> - Bekräfta omedelbart — människan vet att ni fick meddelandet
> - Bearbeta asynkront — blockera inte på långt arbete
> - Använd webhooks för realtid — pollning har latens
> - Polla inte mer än en gång per 5 sekunder — slösar API-anrop
Vanliga problem
Meddelanden försvinner
- markerar automatiskt meddelanden som lästa
- Om ni inte bearbetar dem är de borta
- Lösning: Bearbeta alltid meddelanden innan ni returnerar
Dubbletta svar
- Om er hanterare kraschar kan ni svara två gånger
- Lösning: Gör hanteraren idempotent (kontrollera om redan svarat)
Långsamma svar
- Pollning var 60:e sekund innebär upp till 60 s latens
- Lösning: Polla var 10–30:e sekund, eller använd webhooks
Nästa steg
- Chat API
- Sessionsstart-mönster
- Felåterställning
────────────────────────────────────────────────────────────
# Felåterställning för agenter
SUMMARY: Hur LLM-agenter ska hantera och återställa från fel — ompröva, lagra, lära.
Felåterställning för agenter
Fel inträffar. Nätverk går ner, API:er returnerar 500, Mind Keys löper ut.
Den här guiden visar hur LLM-agenter ska hantera fel elegant och lära sig av dem.
Principer för felhantering
1. Försök igen med backoff — övergående fel löses ofta
2. Lagra felet — lär av mönster
3. Degradera elegant — krascha inte hela sessionen
4. Avisera människan — för fel ni inte kan lösa
HTTP-felhantering
Försök igen med exponentiell backoff
[CODE BLOCK]
Auth-felhantering
[CODE BLOCK]
Lagra fel som minnen
När fel inträffar, lagra dem så framtida sessioner kan lära:
[CODE BLOCK]
Vanliga felscenarier
Scenario 1: Ogiltig Mind Key
[CODE BLOCK]
Scenario 2: Nätverksfel
[CODE BLOCK]
Scenario 3: Hastighetsbegränsad
[CODE BLOCK]
Scenario 4: Serverfel (5xx)
[CODE BLOCK]
Scenario 5: Verktygsanrop misslyckas
[CODE BLOCK]
Mönster: Strömbrytare
För upprepade fel, sluta försöka tillfälligt:
[CODE BLOCK]
Bästa praxis
> [!TIP]
> - Försök alltid om övergående fel — nätverk går ner, servrar händer
> - Försök inte om klientfel (4xx) — de fixar inte sig själva
> - Lagra fel som minnen — lär av mönster
> - Avisera människor om kritiska fel — de behöver veta
> - Degradera elegant — partiellt arbete är bättre än krasch
> - Använd strömbrytare — belasta inte en tjänst som misslyckas
Nästa steg
- Fel API-referens
- Sessionsstart-mönster
- Självläkande tester
────────────────────────────────────────────────────────────
# Taggningsstrategi för minne
SUMMARY: Hur man taggar minnen för effektiv sökning och filtrering — taggningssystemet som skalar.
Taggningsstrategi för minne
Taggar är hemligheten bakom skalbar minnesåtkomst. Den här guiden visar hur man
taggar minnen så att rätt minnen kommer tillbaka vid rätt tidpunkt.
Varför taggar spelar roll
Utan taggar har ni platt fulltextssökning. Med taggar har ni strukturerad
navigation:
[CODE BLOCK]
Taggar möjliggör:
- Snabb filtrering —
- Avgränsad sökning —
- Gruppering — hitta alla "misstag"-minnen för ett projekt
- Korsreferens — minnen som delar taggar är relaterade
Taggningsschema
Projekttaggar
Använd projektnamn som taggar:
[CODE BLOCK]
Teknologitaggar
Använd teknologinamn:
[CODE BLOCK]
Ämnestaggar
Använd ämneskategorier:
[CODE BLOCK]
Statustaggar
Använd statusindikatorer:
[CODE BLOCK]
Typetaggar
Använd typindikatorer:
[CODE BLOCK]
Taggningsregler
Regel 1: 2–5 taggar per minne
För få taggar = dålig upptäckbarhet. För många = brus.
[CODE BLOCK]
Regel 2: Gemener, bindestreck
[CODE BLOCK]
Regel 3: Använd konsekvent vokabulär
Etablera en taggvokabulär och håll er till den:
[CODE BLOCK]
Regel 4: Tagga med sökintention
Fråga: "Hur kommer jag att söka efter detta minne?"
[CODE BLOCK]
Mönster
Mönster 1: Projekt + ämne
[CODE BLOCK]
Sök: (alla Synapse-projektminnen)
Sök: (driftsättningsminnen i Synapse)
Mönster 2: Typ + domän
[CODE BLOCK]
Sök: (alla misstag)
Sök: (driftsättningsmisstag)
Mönster 3: Hierarkisk
För delprojekt inom ett projekt:
[CODE BLOCK]
Sök: (hela Synapse)
Sök: (bara docs-delprojekt)
Mönster 4: Statusspårning
[CODE BLOCK]
Vanliga användningsområden
Hitta alla beslut om ett projekt
[CODE BLOCK]
Hitta alla misstag i en domän
[CODE BLOCK]
Hitta aktivt arbete
[CODE BLOCK]
Hitta minnen om en teknologi
[CODE BLOCK]
Taggunderhåll
Periodisk granskning
[CODE BLOCK]
Slå ihop taggar
Om ni har inkonsekventa taggar ( och ), slå ihop dem:
[CODE BLOCK]
Bästa praxis
> [!TIP]
> - Etablera vokabulär tidigt — konsekventa taggar från dag 1
> - Tagga för sökintention — hur kommer ni att hitta detta senare?
> - 2–5 taggar är sweet spot — för få eller för många är dåligt
> - Gemener + bindestreck — inte
> - Granska periodvis — slå ihop dubbletter, ta bort oanvända
Nästa steg
- Minnesbästa praxis
- FTS5-sökning
- Uppgiftsdrivet arbetsflöde
────────────────────────────────────────────────────────────
# Sessionsstart-mönster
SUMMARY: Den kanoniska sessionsstart-sekvensen som varje LLM-agent bör följa.
KEY CONTEXT:
ALWAYS at session start: 1) GET /memory/recall, 2) GET /chat/poll, 3) GET /mind/tasks?status=in_progress
Build system prompt from recall output.
Process unread chat messages before doing new work.
Resume any in_progress tasks before starting new ones.
Store new learnings as they happen — don't wait until session end.
Sessionsstart-mönster
Varje LLM-agent-session bör följa denna kanoniska startsekvens. Att hoppa över
steg leder till förlorad kontext, missade meddelanden och glömda uppgifter.
Mönstret
[CODE BLOCK]
Implementering
Steg 1: Återkalla alla minnen
> [!CRITICAL]
> Detta är det viktigaste anropet. Utan det har ni inget minne av tidigare
> sessioner.
[CODE BLOCK]
Returnerar oformaterad textsammanfattning av alla minnen, sorterade efter prioritet.
Steg 2: Polla efter olästa chattmeddelanden
[CODE BLOCK]
Returnerar olästa meddelanden från människan. Markerar dem automatiskt som lästa.
Steg 3: Kontrollera pågående uppgifter
[CODE BLOCK]
Returnerar uppgifter ni arbetade med senaste sessionen.
Steg 4: Bygg kontext
Kombinera de tre svaren till er system-prompt:
[CODE BLOCK]
Steg 5: Bearbeta väntande objekt
[CODE BLOCK]
Komplett exempel
[CODE BLOCK]
Vanliga misstag
> [!WARNING]
> - Hoppa över återkallning — ni startar utan kontext, upprepar tidigare misstag
> - Glömma att polla chatt — människans meddelanden förblir obesvarade
> - Ignorera aktiva uppgifter — arbete glöms mitt i utförande
> - Lagra ingenting — sessionen producerar inget beständigt värde
Variationer
Minimalt mönster (LLM:er med låg kontext)
För LLM:er med små kontextfönster, hoppa över full återkallning:
[CODE BLOCK]
Sök sedan efter specifika ämnen vid behov:
[CODE BLOCK]
Aggressivt mönster (långkörande agenter)
För agenter som kör i timmar, lägg till periodisk återkallning:
[CODE BLOCK]
Nästa steg
- Taggningsstrategi för minne
- Uppgiftsdrivet arbetsflöde
- Chattpollningsmönster
────────────────────────────────────────────────────────────
# Uppgiftsdrivet arbetsflöde
SUMMARY: Använd Synapse-uppgifter för att driva LLM-arbetsflöden i flera steg som överlever över sessioner.
Uppgiftsdrivet arbetsflöde
Uppgifter är inte bara att-göra-listor — de är ryggraden i beständiga
LLM-arbetsflöden. Genom att skapa uppgifter för arbete i flera steg säkerställer
ni kontinuitet över sessioner och tillhandahåller granskningsspår för vad som
har gjorts.
Varför uppgiftsdrivet?
Utan uppgifter:
- LLM startar varje session osäker på vad som ska göras
- Arbete i flera steg glöms mitt i utförande
- Ingen registrering av vad som har gjorts
Med uppgifter:
- LLM återupptar pågående uppgifter omedelbart
- Arbete i flera steg överlever över sessioner
- Inbyggt granskningsspår av allt arbete
Mönstret
[CODE BLOCK]
Implementering
Steg 1: Skapa en uppgift för arbete i flera steg
[CODE BLOCK]
Steg 2: Spåra förlopp i uppgiftsbeskrivning
[CODE BLOCK]
Steg 3: Återuppta över sessioner
[CODE BLOCK]
Steg 4: Slutför och arkivera
[CODE BLOCK]
Fullständigt exempel: Driftsättningsarbetsflöde
[CODE BLOCK]
Uppgiftshierarki
För komplext arbete, använd förälder-barn-uppgiftsrelationer:
[CODE BLOCK]
Sök efter deluppgifter:
[CODE BLOCK]
Statusarbetsflöde
[CODE BLOCK]
Pending
Uppgift skapad men inte startad. Används för planerat arbete.
In Progress
Pågår. Uppdatera beskrivning med förlopp.
Done
Slutförd. Beskrivning bör inkludera sammanfattning.
Cancelled
Övergiven. Beskrivning bör inkludera anledning.
Bästa praxis
> [!TIP]
> - Skapa uppgifter för arbete i flera steg — enstaka steg behöver ingen uppgift
> - Uppdatera beskrivning med förlopp — möjliggör återupptagande
> - Använd hög prioritet för aktivt arbete — visas i återkallning
> - Slutför uppgifter när klara — låt dem inte ligga som inprogress
> - Lagra slutförandesammanfattningar som minnen — långsiktig referens
Vanliga mönster
Mönster: Buggfix-arbetsflöde
[CODE BLOCK]
Mönster: Forskningsarbetsflöde
[CODE BLOCK]
Nästa steg
- Sessionsstart-mönster
- Chattpollningsmönster
- Felåterställning
## KATEGORI: VANLIGA FRÅGOR
Vanliga frågor och vanliga problem.
────────────────────────────────────────────────────────────
# API FAQ
SUMMARY: Vanliga API-frågor — autentisering, hastighetsgränser, felhantering, endpoint-upptäckning.
API FAQ
Vanliga frågor om Synapse API.
Hur autentiserarar jag?
Två metoder:
1. Mind Key (för data-endpoints):
2. JWT (för konto-endpoints):
Eller via queryparameter (60 req/min-gräns):
Se Autentisering.
Vad är skillnaden mellan Mind Key och JWT?
- Mind Key: klientomfattande, löper aldrig ut, för minnes-/chatt-/uppgiftsdata
- JWT: användaromfattande, 7 dagars giltighet, för konto-/mind-hantering
Se Mind Key vs JWT.
Varför får jag 401 Unauthorized?
Vanliga orsaker:
1. Saknad -header
2. Ogiltig Mind Key (verifiera att den börjar med )
3. Användning av en JWT där en Mind Key krävs (eller tvärtom)
4. Mind Key har återkallats
Lösning: Verifiera din token. Se Autentisering.
Varför får jag 404 Not Found?
Ni använde en felaktig endpointsökväg. Synapse har endast de sökvägar som listas
i .
Lösning: Anropa för att se alla giltiga sökvägar. Gissa inte.
Varför får jag 429 Too Many Requests?
Ni använder -queryparameter-autentisering, som är begränsad till 60/min.
Lösning: Byt till -header (ingen hastighetsgräns).
Se Hastighetsgränser.
Hur listar jag alla endpoints?
[CODE BLOCK]
Hur hittar jag rätt endpoint?
1. Kontrollera för den maskinläsbara listan
2. Kontrollera för fullständig API-dokumentation
3. Bläddra i för dokumentationssystemet
4. Använd för OpenAPI 3.0-specifikation
Kan jag använda GET istället för POST?
Vissa POST-endpoints har GET-motsvarigheter för URL-endast-verktyg:
- ↔
- ↔
- ↔
Kontrollera för tillgängliga GET-varianter.
Hur hanterar jag fel?
Alla fel returnerar JSON:
[CODE BLOCK]
Se Fel & felhantering.
Vad är gränsen för begärans body?
10 MB. För större payloads (t.ex. filuppladdningar), använd multipart-endpoints.
Stöder API:et CORS?
Ja. Alla endpoints returnerar:
[CODE BLOCK]
Finns det ett SDK?
Ja:
- Node.js:
- MCP:
Se API-översikt för detaljer.
Hur paginerar jag?
Använd och :
[CODE BLOCK]
Standardgräns: 100. Max: 500.
Kan jag filtrera minnen efter kategori eller tagg?
Ja:
[CODE BLOCK]
Hur söker jag bland minnen?
På två sätt:
1. FTS5 nyckelordssökning:
2. Semantisk sökning:
Se FTS5-sökning och Semantisk sökning.
Hur uppdaterar jag ett minne?
POST med samma + — det befintliga minnet uppdateras,
inte dupliceras.
[CODE BLOCK]
Hur tar jag bort ett minne?
[CODE BLOCK]
Kan jag ta bort i bulk?
Ja:
[CODE BLOCK]
Nästa steg
- API-översikt
- Fel & felhantering
- Autentisering
────────────────────────────────────────────────────────────
# Allmän FAQ
SUMMARY: Vanliga frågor om Synapse — vad det är, hur det fungerar, vem det är för.
Allmän FAQ
Vanliga frågor om Synapse.
Vad är Synapse?
Synapse är ett beständigt minnes-API för LLM-agenter. Det ger er
AI-assistent en permanent, sökbar hjärna som överlever mellan sessioner. Istället
för att glömma allt när chatten stängs, lagrar och hämtar LLM:en minnen via ett
enkelt HTTP-API.
Lär dig mer: Vad är Synapse?
Vem är Synapse för?
- LLM-agentutvecklare som behöver beständigt tillstånd
- Avancerade användare som kör lokala LLM:er med egna agenter
- Team som bygger AI-assistenter med delat minne
- Automationsingenjörer som kedjar LLM-anrop över sessioner
Är Synapse gratis?
Synapse är värd på och gratis för personligt
bruk. För egenvärd se repo.
Hur skiljer sig Synapse från ChatGPT Memory?
| Funktion | ChatGPT Memory | Synapse |
|---------|---------------|---------|
| Lagring | OpenAI-servrar | Din server |
| API-åtkomst | Nej | Ja (REST + MCP) |
| Multitenant | Nej | Ja (minds) |
| Anpassade kategorier | Nej | Ja (8 kategorier) |
| Fulltextssökning | Begränsad | FTS5 + semantisk |
| Självhostbart | Nej | Ja |
Vilka LLM:er fungerar med Synapse?
Alla LLM:er som kan göra HTTP-anrop eller använda MCP:
- Claude (Anthropic) — via MCP eller direkt API
- GPT-4 / GPT-3.5 (OpenAI) — via funktionsanrop + API
- Gemini (Google) — via funktionsanrop + API
- Llama / Mistral (lokal) — via anpassad integration
- Vilken LLM som helst via Synapse MCP-server
Måste jag hosta Synapse själv?
Nej. Den värdhostade versionen på är tillgänglig
för offentligt bruk. Egenvärd är valfritt (för integritet, anpassning eller
luftgappade miljöer).
Hur mycket data kan jag lagra?
Det finns inga hårda gränser på den värdhostade versionen. Typisk användning:
- 100–1000 minnen per mind
- 1–10 KB per minne (innehållsfält)
- Totalt: 10 MB per mind
För större skala, kör egenvärd.
Är min data privat?
Ja. Varje mind är isolerad (se Multitenancy).
Andra användare kan inte se er data. Värden (Schäfer Services) har åtkomst men
visar inte användardata.
För maximal integritet, kör egenvärd.
Kan jag exportera min data?
Ja. Använd för att exportera alla minnen som JSON. Se
Säkerhetskopiering & återställning.
Vad händer om jag tappar min Mind Key?
Mind Keys visas endast en gång vid skapandet. Om tappad:
1. Logga in med din e-post/lösenord för att få en JWT
2. Skapa en ny mind via
3. Spara den nya Mind Key
4. (Valfritt) Ta bort den gamla mind via
Ni kan inte återhämta minnen från en mind vars nyckel är tappad.
Kan flera LLM-agenter dela en mind?
Ja. Alla agenter som använder samma Mind Key delar den mindens data. För
koordinerat multi-agent-arbete, se Multi-agent-koordinering.
Fungerar Synapse offline?
Nej, Synapse kräver internetanslutning till servern (antingen värdhostad eller
egenvärd). För offline LLM:er, kör Synapse lokalt.
Hur snabb är minnessökning?
- FTS5 nyckelordssökning: < 10 ms för 1000 minnen
- Semantisk sökning: 50–100 ms för 1000 minnen
- Full återkallning: < 50 ms för 1000 minnen
Se FTS5-sökning för detaljer.
Kan jag använda Synapse utan en LLM?
Ja. Synapse är ett generiskt minnes-API. Ni kan använda det från vilken
applikation som helst som har nytta av beständig, sökbar nyckel-värde-lagring
med kategorier och taggar.
Nästa steg
- Vad är Synapse?
- Snabbstart
- API FAQ
────────────────────────────────────────────────────────────
# MCP FAQ
SUMMARY: Vanliga frågor om MCP-integration — verktyg, transporter, felsökning.
MCP FAQ
Vanliga frågor om Synapse MCP-server.
Vad är MCP?
MCP (Model Context Protocol) är en öppen standard av Anthropic för
LLM-verktygsintegration. Istället för att klistra in API-dokumentation i
prompter registrerar ni verktyg hos en MCP-server, och LLM:en anropar dem som
inbyggda funktioner.
Se Vad är MCP?.
Hur många verktyg exponerar Synapse MCP?
79 verktyg i 12 kategorier: minne, chatt, schemaläggare, uppgifter, skript,
datorer, push, användare, verktyg, visualisering, delning, webhooks, webbläsare.
Se Vad är MCP? för fullständig lista.
Vilka MCP-klienter stöds?
- Claude Desktop (macOS, Windows)
- Claude Code (terminal)
- Cursor (IDE)
- Continue.dev (VS Code, JetBrains)
- Cline (VS Code)
- Vilken MCP-kompatibel klient som helst
Se Claude Desktop-konfiguration för konfigurationsexempel.
Vilka transporter stöds?
1. stdio (lokal, rekommenderas för skrivbord)
2. HTTP/SSE (fjärr, multitenant)
3. WebSocket (mobil, hög volym)
Hur konfigurerar jag Claude Desktop?
Redigera :
[CODE BLOCK]
Se Claude Desktop-konfiguration.
Varför visas inte verktyg i Claude Desktop?
1. Starta om Claude Desktop helt (Cmd+Q på macOS)
2. Kontrollera att konfigurationsfilen är giltig JSON
3. Verifiera att Node.js 18+ är installerat
4. Kontrollera MCP-loggar:
Se MCP-felsökning.
Hur använder jag en annan mind?
Ändra i er MCP-konfiguration och starta om klienten.
För flera minds, kör flera MCP-serverinstanser med olika Mind Keys.
Kan jag begränsa vilka verktyg som exponeras?
Ja, använd verktygsprofiler:
- : 8 sammansatta verktyg (500 tokens)
- : 25 verktyg (2 500 tokens)
- : 119 verktyg (8 250 tokens, standard)
Sätt via -miljövariabel eller -header.
Hur felsöker jag MCP-problem?
1. Kör MCP-server manuellt:
2. Kontrollera klientloggar (varierar per klient)
3. Verifiera att Mind Key fungerar:
4. Kontrollera Synapse-hälsa:
Se MCP-felsökning.
Är MCP-servern gratis?
Ja. npm-paketet är öppen källkod. Den värdhostade
MCP-servern på är gratis för offentligt bruk.
Kan jag köra MCP-servern egenvärd?
Ja:
[CODE BLOCK]
Hur skiljer sig MCP från direkta API-anrop?
| Aspekt | Direkt API | MCP |
|--------|-----------|-----|
| LLM behöver veta | URL:er, headers, auth | Bara verktygsnamn |
| Auth-hantering | Manuell | Automatisk (miljövariabel) |
| Verktygsupptäckt | Läs /endpoints | Automatisk via MCP-protokoll |
| Felhantering | Manuell | Standardiserad |
| Bäst för | Anpassade integrationer | LLM-agenter |
Kan jag bygga en egen MCP-klient?
Ja. Använd det officiella MCP-SDK:et:
- TypeScript:
- Python:
Se Anpassad MCP-klient.
Hur rapporterar jag MCP-buggar?
Öppna ett ärende:
Inkludera:
- MCP-serverversion
- Klientnamn och version
- Operativsystem
- Relevanta loggar
- Steg för att reproducera
Nästa steg
- Vad är MCP?
- Claude Desktop-konfiguration
- MCP-felsökning
────────────────────────────────────────────────────────────
# Felsöknings-FAQ
SUMMARY: Lösningar på vanliga Synapse-problem — autentisering, nätverk, data, driftsättning.
Felsöknings-FAQ
Lösningar på vanliga Synapse-problem.
Jag kan inte logga in
Symptom
- returnerar 401
- "Invalid email or password"
Lösningar
1. Verifiera att e-postadressen är korrekt — skiftesokänslig
2. Kontrollera lösenordet — minst 6 tecken
3. Registrera först om ni inte har ett konto:
4. Återställ lösenord (om SMTP konfigurerat) via webbgränssnittet
Jag har tappat min Mind Key
Symptom
- Kan inte komma åt minnen
- Mind Key har raderats/tappats
Lösningar
Mind Keys kan inte återställas. Ni måste:
1. Logga in för att få JWT:
2. Lista minds: (med JWT)
3. Skapa ny mind:
4. Spara ny Mind Key
5. (Valfritt) Ta bort gammal mind:
Data i den gamla mind är förlorad om ni inte kan hitta Mind Key.
API-anrop returnerar 401
Symptom
- Alla API-anrop returnerar 401 Unauthorized
- "Mind Key fehlt oder ungültig"
Lösningar
1. Verifiera header-format:
2. Kontrollera att Mind Key börjar med (inte som är JWT)
3. Testa direkt:
[CODE BLOCK]
4. Mind Key kan vara återkallad — skapa en ny mind
Se Autentisering.
API-anrop returnerar 404
Symptom
- 404 Not Found
- "Route not found"
Lösningar
> [!CRITICAL]
> Gissa inte endpointsökvägar. Endast sökvägar i existerar.
1. Kontrollera giltiga endpoints:
2. Jämför URL exakt — skiftesokänslig, inga avslutande snedstreck
3. Kontrollera HTTP-metod — vs är olika
API-anrop returnerar 429
Symptom
- 429 Too Many Requests
- "Rate limit exceeded"
Lösningar
1. Byt till header-auth (ingen hastighetsgräns):
[CODE BLOCK]
2. Vänta sekunder om ni måste använda
Se Hastighetsgränser.
Minnessökning returnerar inga resultat
Symptom
- returnerar tomt
- Vet att minnen finns
Lösningar
1. Verifiera att minnen finns:
2. Kontrollera söksyntax — FTS5 har specifik syntax
3. Prova enklare fråga — istället för
4. Använd semantisk sökning för begreppsliga frågor:
Se FTS5-sökning.
Minnen persistens inte
Symptom
- POST /memory returnerar framgång
- GET /memory/recall visar dem inte
Lösningar
1. Verifiera samma Mind Key — olika nycklar = olika minds
2. Kontrollera svar — POST returnerar
3. Prova GET /memory (JSON-lista) istället för /memory/recall (text)
4. Kontrollera filter — eller kan dölja dem
Verktyg visas inte i Claude Desktop
Symptom
- Claude Desktop visar 0 verktyg
- Ingen 🔌-ikon
Lösningar
1. Starta om Claude Desktop helt (Cmd+Q)
2. Verifiera att konfigurationsfilen är giltig JSON
3. Kontrollera att Node.js 18+ är installerat
4. Kör MCP manuellt:
5. Kontrollera loggar:
Se MCP-felsökning.
Synapse är offline
Symptom
- Kan inte nå synapse.schaefer.zone
- curl time-out
Lösningar
1. Kontrollera er internetanslutning — prova en annan webbplats
2. Kontrollera Synapse-hälsa:
3. Vänta — kan vara tillfälligt avbrott eller driftsättning
4. Kontrollera statussida (om tillgänglig)
För egenvärd: kontrollera Docker-containerstatus, databasanslutning.
Databasfel
Symptom
- 500 Internal Server Error
- "Database connection failed"
Lösningar
För egenvärd:
1. Kontrollera att PostgreSQL körs:
2. Kontrollera DATABASEURL i env
3. Kontrollera migreringar:
4. Kontrollera diskutrymme:
För värdhostad: rapportera till support.
Webhook utlöses inte
Symptom
- Registrerad webhook men får inga återanrop
- Ingen POST till er URL
Lösningar
1. Verifiera att URL:en är nåbar:
2. Kontrollera händelsefilter — matchar alla minneshändelser
3. Testa webhook:
4. Kontrollera att webhook är aktiverad:
5. Verifiera SSL — Synapse kräver giltig HTTPS för webhook-URL:er
Se Webhooks API.
Cron-jobb körs inte
Symptom
- Skapat cron-jobb men det utlöses inte
- uppdateras inte
Lösningar
1. Kontrollera schemasyntax — måste vara giltig 5-fältig cron ELLER heltal sekunder
2. Verifiera att endpoint tillåts — måste vara http(s), inga privata IP:er
3. Kontrollera att jobbet är aktiverat:
4. Vänta till nästa schemalagda tid — cron är inte omedelbar
Se Cron & Scheduler.
Behöver mer hjälp?
1. Kontrollera befintlig dokumentation:
2. Sök i dokumentation:
3. Öppna ärende:
4. Kontakt: se -sida
Nästa steg
- Fel & felhantering
- API FAQ
- MCP-felsökning