Skip to main content

​
Overview

Synap provides multiple integration points, each serving a different purpose. Whether you are building a memory-augmented chatbot, migrating historical data, configuring your memory architecture, or monitoring pipeline health, there is a dedicated component for the job. This page serves as a map: it describes each component, explains when to use it, and links to the relevant documentation.

​
Components

SDK

Primary programmatic interface. The Python SDK (maximem_synap) is the main way your application interacts with Synap. Use it for:
  • Ingesting memories from conversations
  • Retrieving context for agent prompts
  • Managing conversation lifecycle (start, compact, end)
  • Local caching for reduced latency
The SDK handles authentication, connection management, retries, and local caching. It is the recommended integration point for application code.

REST API

HTTP API for bootstrap and administrative operations. The REST API provides endpoints for operations that don’t go through the SDK:
  • Bootstrap ingestion of historical data (POST /v1/memories/batch)
  • Organizational context management
  • Data migration
  • Programmatic instance and client management
Use the API when you need direct HTTP access or are integrating from a non-Python environment.

Agentic Context Cloud

The managed backend. The Agentic Context Cloud is Synap’s server-side infrastructure. It runs:
  • The multi-stage ingestion pipeline (categorization, extraction, chunking, entity resolution, organization)
  • Memory storage in vector and graph datastores
  • Entity resolution and registry management
  • Retrieval query processing and ranking
  • Retention and eviction policies
This is fully managed — you do not deploy or maintain any infrastructure. The Cloud is accessed through the SDK and API.

Datastores

Vector store and graph store. The underlying storage layer managed by Synap Cloud:
  • Vector store: Stores embeddings for semantic similarity search. Configured via MACA (namespace, dimensions, distance metric).
  • Graph store: Stores entity relationships for graph-based queries. Configured via MACA (namespace, connection settings).
You configure datastores through MACA but do not interact with them directly — the SDK and Cloud handle all read/write operations.

Local Cache

SQLite-based client-side cache. The SDK includes an optional local cache that stores retrieval results on the client side:
  • Reduces latency for repeated queries
  • Reduces API calls to the Cloud
  • Configurable via SDKConfig.cache_backend
  • Automatically invalidated based on TTL settings
The local cache is especially useful for applications with high query volumes or latency-sensitive workloads.

Dashboard

Web UI for management and monitoring. The Dashboard provides a visual interface for:
  • Managing instances and clients
  • Configuring memory architecture (MACA)
  • Monitoring ingestion pipeline health
  • Team management and access control
  • Webhook configuration
  • Analytics and usage metrics
Use the Dashboard for initial setup, ongoing monitoring, and configuration changes that don’t need to be automated.

Connectors

Pre-built integrations for external systems. Connectors pull data from external sources (CRMs, helpdesks, document stores) and submit it to Synap’s ingestion pipeline. Planned connectors include Zendesk, Intercom, Slack, Notion, and more.Use connectors when you want to automatically sync data from external systems without writing custom integration code.

​
Architecture Overview

The following diagram shows how the components connect: 
┌──────────────────────────────────────────────────────────────────┐
│                      Your Application                            │
│                                                                  │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│   │  Agent / LLM │◄───│  Synap SDK   │───►│ Local Cache  │      │
│   └──────────────┘    └──────┬───────┘    └──────────────┘      │
│                              │                                   │
└──────────────────────────────┼───────────────────────────────────┘
                               │ HTTPS / gRPC
                               ▼
┌──────────────────────────────────────────────────────────────────┐
│                    Synap Agentic Context Cloud                   │
│                                                                  │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│   │   REST API   │    │  Ingestion   │    │  Retrieval   │      │
│   │   Gateway    │    │  Pipeline    │    │  Engine      │      │
│   └──────────────┘    └──────┬───────┘    └──────┬───────┘      │
│                              │                    │              │
│                              ▼                    ▼              │
│                    ┌──────────────────────────────────┐          │
│                    │        Storage Layer             │          │
│                    │  ┌─────────┐  ┌──────────────┐  │          │
│                    │  │ Vector  │  │    Graph      │  │          │
│                    │  │ Store   │  │    Store      │  │          │
│                    │  └─────────┘  └──────────────┘  │          │
│                    └──────────────────────────────────┘          │
│                                                                  │
│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│   │  Entity      │    │  Dashboard   │    │  Connectors  │      │
│   │  Resolution  │    │  (Web UI)    │    │  (External)  │      │
│   └──────────────┘    └──────────────┘    └──────────────┘      │
└──────────────────────────────────────────────────────────────────┘

​
Which Component to Use When

Use the table below to find the right component for your task:
TaskComponentLink
Ingest memories from conversationsSDKSDK Ingestion
Retrieve context for agent promptsSDKSDK Context
Manage conversation lifecycleSDKSDK Initialization
Bulk-load historical dataREST APIMemory API
Load organizational documentsREST API or SDKOrg Context Lifecycle
Configure memory architectureDashboard or REST APIMACA Configuration
Monitor pipeline healthDashboardDashboard Overview
Manage team access and permissionsDashboardDashboard Overview
Set up webhooks for events (planned)Dashboard or REST APIWebhooks (Planned)
Sync data from CRM/helpdeskConnectorsConnectors Overview
View analytics and usage metrics (planned)DashboardDashboard Monitoring & Analytics (Planned)
Manage instances programmaticallyREST APIInstances API
For most applications, you will primarily use the SDK for runtime operations (ingest + retrieve) and the Dashboard for setup and monitoring. The REST API is used for bootstrap data loading and administrative automation.

​
Integration Patterns

The most common pattern: your agent retrieves context before generating, then ingests the conversation after.
User Message → Retrieve Context → Build Prompt → LLM Generate → Return Response → Ingest Turn
See Integration Guide for full code examples.

​
Next Steps

Installation

Install the SDK and set up your environment.

SDK Initialization

Initialize the SDK in your application.

Dashboard

Explore the management dashboard.