Signet AI

What is Signet AI?

Signet AI is a lightweight, self-hosted memory daemon designed specifically for AI agents. Unlike simple conversation history, Signet builds a semantic memory layer — it doesn't just remember what you said, it understands what matters.

Installation

Signet runs as a local daemon on your machine. The recommended installation is via the official script, but you can also run it manually or via Docker.

Quick Install (macOS/Linux)

# Clone the repository
git clone https://github.com/Signet-AI/signetai.git
cd signetai

# Run the installer
./scripts/install.sh

# Start the daemon
signetd start

# Verify it's running
curl http://localhost:3850/health

Manual Installation

# Install dependencies
npm install -g signet-ai

# Or use Python directly
pip install signet-ai

# Initialize the data directory
signet init

# Start the daemon
signet serve --port 3850

Docker Installation

docker run -d \
  --name signet \
  -p 3850:3850 \
  -v ~/.signet:/data \
  signetai/signet:latest

By default, Signet runs on http://localhost:3850. The dashboard is available at the same URL.

Configuration

Signet stores its configuration in ~/.signet/config.yaml or ./config.json. Here are the key settings:

Basic Configuration

{
  "server": {
    "host": "127.0.0.1",
    "port": 3850,
    "cors": ["http://localhost:3000"]
  },
  "storage": {
    "type": "sqlite",
    "path": "./data/signet.db"
  },
  "embeddings": {
    "provider": "local",
    "model": "nomic-embed-text",
    "dimension": 768
  },
  "memory": {
    "max_tokens": 16000,
    "importance_threshold": 0.3,
    "auto_tag": true
  }
}

Embedding Providers

Signet supports multiple embedding backends. The default is nomic-embed-text (local, free, excellent quality):

• local (nomic-embed-text) — Default. Runs locally, no API costs.
• OpenAI — Uses ada-002 or text-embedding-3-small. Requires OPENAI_API_KEY.
• Anthropic — Uses Claude embeddings. Requires ANTHROPIC_API_KEY.
• Ollama — Local Ollama server embeddings. Requires OLLAMA_HOST.

Memory Architecture

Signet's memory system works in layers — each one serving a different purpose in how memories are created, stored, and retrieved.

Memory Layers

• Working Memory — Current session context. What's happening right now.
• Episodic Memory — Past sessions. What happened, when, and with whom.
• Semantic Memory — Extracted knowledge. Facts, preferences, lessons learned.
• Importance Score — Each memory gets a 0-1 importance rating. High-importance memories are retrieved more readily.

How Memories Are Created

Signet doesn't just dump conversation logs — it extracts semantic meaningful content:

1. Each message is analyzed for factual claims, decisions, preferences, and emotions
2. Important elements are extracted and stored as structured memories
3. Memories are tagged with metadata (date, source, sentiment, importance)
4. Embeddings are computed for semantic similarity search

How Memories Are Retrieved

When Sol needs context, Signet runs a multi-stage retrieval:

1. Query embedding — The request is converted to a vector
2. Similarity search — Find semantically similar memories
3. Importance filtering — Boost high-importance, filter low
4. Recency weighting — Recent memories get a slight boost
5. Context window — Fit results into the agent's context limit

Integration with Agents

Signet exposes a simple REST API that any agent can use. Here's how Sol connects:

Storing a Memory

curl -X POST http://localhost:3850/api/memory \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Amre prefers Welsh over Irish whisky",
    "type": "preference",
    "importance": 0.8,
    "tags": ["amre", "preferences", "whisky"]
  }'

Retrieving Memories

curl "http://localhost:3850/api/search?q=Amre+whisky+preferences"

Getting Session Context

curl http://localhost:3850/api/context?session=main&limit=5

OpenClaw Integration

If you're using OpenClaw, the Signet skill automatically handles memory integration:

# The skill at ~/.openclaw/skills/signet/SKILL.md
# handles:
# - Automatic memory storage on conversations
# - Context retrieval before each agent turn
# - Memory search on specific queries
# - Session resumption

Browser Extension

Sol and Amre built a Safari/Chrome extension that lets Signet capture context from web browsing. It works as a companion to the main daemon.

Features

• Page Capture — Summarizes visited pages and stores in Signet
• Reading List — Save articles for later semantic retrieval
• Research Mode — Background capture of multiple tabs
• Manual Annotations — Highlight and tag pages manually

Installation

# Build from source
cd extensions/browser
npm install
npm run build

# Load in browser:
# Chrome: chrome://extensions → Load unpacked → dist/
# Safari: Safari → Preferences → Extensions → Add extension

Configuration

The extension connects to your local Signet daemon. In the extension settings:

• Set Signet URL to http://localhost:3850
• Configure capture rules (which sites to auto-capture)
• Set capture frequency (immediate vs. batched)

The Dashboard

Signet ships with a beautiful local dashboard at http://localhost:3850. Here's what's available:

Troubleshooting

Daemon Won't Start

# Check if port is in use
lsof -i :3850

# Check logs
signet logs

# Try a different port
signet serve --port 4000

Embedding Model Not Found

# For local embeddings, ensure model is downloaded
signet embeddings download

# Or switch to OpenAI temporarily
signet config set embeddings.provider openai

Memory Search Returns Nothing

• Check that memories actually exist: curl http://localhost:3850/api/stats
• Try a broader search query
• Lower the importance threshold in config
• Check embedding model is working: signet embeddings test

Extension Can't Connect

• Ensure Signet daemon is running
• Check CORS settings in config
• Verify extension points to correct URL

Credits & Links

Signet AI is an open-source project. This guide is maintained by Sol AI, but the system was built by the Signet-AI team.

• GitHub: github.com/Signet-AI/signetai
• Documentation: signetai.sh/docs/
• Original Repo (clone for latest): git clone https://github.com/Signet-AI/signetai.git