Documentation

Quickstart

Claude.ai / Claude Desktop Connector

Connect Second Brain directly to Claude.ai or the Claude Desktop app — no API key needed. Claude authenticates via OAuth.

You can manage connected apps and revoke access from your Account page.

SKILL.md — Make Claude Use Second Brain Automatically

By default, Claude won't write to Second Brain unless you ask it to. To make it proactive — automatically saving important information and checking for context — add the SKILL.md to your project or conversation.

For Claude Code projects

Add this line to your project's CLAUDE.md:

Follow the instructions at https://stovaro.com/SKILL.md for using Second Brain.

Claude Code will fetch and follow the skill automatically. It will save decisions, preferences, and important context to your Second Brain as you work.

For Claude.ai / Desktop conversations

Paste this at the start of a conversation (or add it to your custom instructions):

You have access to Second Brain via the connected MCP tools.
Follow the instructions at https://stovaro.com/SKILL.md — save
important information proactively and search before answering
questions that might have prior context.

What the skill tells Claude to do

• Save automatically — decisions, preferences, research findings, and anything the user would want recalled later
• Search first — check for existing context before starting work or making recommendations
• Update, don't duplicate — append to existing notes instead of creating duplicates
• Link related notes — build a connected knowledge graph over time

View the full skill: stovaro.com/SKILL.md

Claude Code (CLI)

Run this in your terminal:

claude mcp add --transport http second-brain https://stovaro.com/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

To make it available globally (not just the current project):

claude mcp add --transport http --scope user second-brain https://stovaro.com/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

Restart Claude Code after adding. Then try: "save a note called test to my second brain"

Claude Desktop

Edit your config file:

• Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add this to the file (create it if it doesn't exist):

{
  "mcpServers": {
    "second-brain": {
      "url": "https://stovaro.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Restart Claude Desktop. You'll see "second-brain" in the MCP tools list.

Cursor / Windsurf

Create .cursor/mcp.json (Cursor) or .windsurf/mcp.json (Windsurf) in your project root:

{
  "mcpServers": {
    "second-brain": {
      "url": "https://stovaro.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

cURL

Test your connection from the terminal:

# Save your API key
export SB_KEY="YOUR_API_KEY"

# Create a note
curl -X POST https://stovaro.com/api/v1/notes \
  -H "Authorization: Bearer $SB_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "My First Note", "content": "Hello from the API!", "tags": ["test"]}'

# List all notes
curl https://stovaro.com/api/v1/notes \
  -H "Authorization: Bearer $SB_KEY"

# Search notes
curl "https://stovaro.com/api/v1/search?q=hello" \
  -H "Authorization: Bearer $SB_KEY"

# Get all tags
curl https://stovaro.com/api/v1/tags \
  -H "Authorization: Bearer $SB_KEY"

# Delete a note (replace 1 with note ID)
curl -X DELETE https://stovaro.com/api/v1/notes/1 \
  -H "Authorization: Bearer $SB_KEY"

Python

import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://stovaro.com/api/v1"
headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

# Create a note
requests.post(f"{BASE}/notes", headers=headers, json={
    "title": "From Python",
    "content": "Created programmatically",
    "tags": ["python", "automation"]
})

# List notes
notes = requests.get(f"{BASE}/notes", headers=headers).json()

# Search
results = requests.get(f"{BASE}/search", headers=headers, params={"q": "python"}).json()

# Create a link between notes
requests.post(f"{BASE}/links", headers=headers, json={
    "source_note_id": 1,
    "target_note_id": 2,
    "relation_type": "related_to"
})

JavaScript / Node.js

const API_KEY = "YOUR_API_KEY";
const BASE = "https://stovaro.com/api/v1";
const headers = {
  "Authorization": `Bearer ${API_KEY}`,
  "Content-Type": "application/json"
};

// Create a note
await fetch(`${BASE}/notes`, {
  method: "POST", headers,
  body: JSON.stringify({
    title: "From JavaScript",
    content: "Hello from Node!",
    tags: ["js"]
  })
});

// List notes
const notes = await fetch(`${BASE}/notes`, { headers }).then(r => r.json());

// Search
const results = await fetch(`${BASE}/search?q=hello`, { headers }).then(r => r.json());

// Get graph neighbors
const graph = await fetch(`${BASE}/graph/neighbors/1?depth=2`, { headers }).then(r => r.json());

API Reference

Authentication

Every request requires a Bearer token in the Authorization header:

Authorization: Bearer YOUR_API_KEY

Requests without a valid token return 401 Unauthorized.

Scopes

API keys have scoped permissions. The default key gets all scopes:

Rate Limits

Exceeding limits returns 429 Too Many Requests.

Endpoints

Notes

Search

Links & Graph

Response Codes

MCP Tools Reference

When connected via MCP, your AI agent gets 9 tools:

Example Use Cases

When you learn something important about this project — architecture decisions,
user preferences, bug fixes, or conventions — save it to Second Brain using
create_note. Before starting work, use search_notes to check for relevant context.

# Agent researches a topic and saves findings
create_note(
  title: "React Server Components",
  content: "RSCs execute on the server, reducing client bundle size...",
  tags: ["react", "architecture", "research"]
)

# Weeks later, a different agent searches for context
search_notes(query: "server-side rendering react")
# → Returns the RSC note plus any related findings

# Agent connects related discoveries
link_notes(source_id: 1, target_id: 2, relation_type: "related_to")

# Claude Code saves an architecture decision at 2pm
create_note(title: "Auth: JWT not sessions", content: "We chose JWT because...")

# Cursor reads it at 3pm when implementing auth
search_notes(query: "authentication approach")
# → Finds the decision, implements accordingly

# A nightly cron agent summarizes the day's knowledge
list_notes(tag: "decision")
# → All decisions in one place

# Build a web of connected knowledge
create_note(title: "Elixir", content: "Functional language on the BEAM VM...", tags: ["language"])
create_note(title: "Phoenix", content: "Web framework for Elixir...", tags: ["framework"])
create_note(title: "LiveView", content: "Server-rendered reactive UIs...", tags: ["framework"])

# Connect them
link_notes(source_id: 2, target_id: 1, relation_type: "derived_from")  # Phoenix → Elixir
link_notes(source_id: 3, target_id: 2, relation_type: "derived_from")  # LiveView → Phoenix

# Traverse the graph
get_links(id: 1, direction: "incoming")
# → Phoenix and LiveView both link back to Elixir