Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/bradygaster/squad/llms.txt

Use this file to discover all available pages before exploring further.

Squad supports a plugin marketplace for extending agent capabilities. Plugins are self-describing packages defined by a plugin.manifest.json file. They can add custom knowledge sources that agents read during sessions, memory storage backends that persist context in specialized ways, and MCP-connected tools that give agents access to external services. Plugins are installed into your project and travel with your .squad/ directory — the same plugin configuration is active for everyone who clones the repository.
The plugin marketplace is in active development. Plugin APIs and the manifest schema may change between Squad releases. Check the changelog when upgrading.

​
Plugin Types

​
Knowledge plugins

Knowledge plugins add custom knowledge sources to agents. During a session, an agent with a knowledge plugin loaded can reference the plugin’s artifacts when answering questions about the codebase. The plugin-knowledge-graphify sample adds knowledge graph integration. Its manifest: 
{
  "id": "graphify-knowledge",
  "name": "Graphify Knowledge Graph",
  "version": "1.0.0",
  "description": "Example Squad knowledge plugin that documents integration with the safishamsi/graphify code knowledge graph tool.",
  "authors": ["Squad"],
  "license": "MIT",
  "squad": ">=0.9.1",
  "components": {
    "knowledge": ["graphify"]
  },
  "repository": {
    "type": "github",
    "url": "https://github.com/safishamsi/graphify"
  },
  "upstream": {
    "package": "graphifyy",
    "registry": "pypi",
    "installCommand": "uv tool install graphifyy",
    "docs": "https://github.com/safishamsi/graphify"
  },
  "mcp": {
    "available": false,
    "reason": "Graphify is represented here as a CLI and Copilot skill integration, not a Squad-managed MCP memory provider."
  },
  "providers": [
    {
      "id": "graphify",
      "type": "knowledge",
      "mode": "read",
      "protocol": "static-artifact",
      "description": "Knowledge graph provider contract for code relationship guidance already materialized as static artifacts.",
      "artifact": "knowledge/graphify/graphify-integration.md",
      "capabilities": [
        "knowledge-graph",
        "code-relationship-analysis",
        "static-report-guidance"
      ]
    }
  ],
  "runtime": {
    "capabilities": [
      {
        "type": "artifact-generation",
        "provider": "graphify",
        "lifecycle": ["onEnable", "onMemoryRefresh"],
        "outputPaths": [
          "knowledge/graphify/graph.json",
          "knowledge/graphify/GRAPH_REPORT.md"
        ]
      }
    ]
  },
  "files": [
    {
      "source": "knowledge/graphify-integration.md",
      "target": "knowledge/graphify/graphify-integration.md",
      "type": "doc"
    }
  ]
}
Knowledge plugins can use two protocols:
  • static-artifact — reads a pre-generated markdown or JSON file as context
  • mcp — connects to a live MCP server tool for dynamic knowledge queries

​
Memory plugins

Memory plugins provide custom memory storage backends. Instead of storing agent memory in .squad/ files on disk, a memory plugin can route memory operations to an external service — a vector database, a spatial memory system, or a custom store. The plugin-memory-mempalace sample uses a memory-palace-style layout: 
{
  "id": "mempalace-memory",
  "name": "MemPalace Memory",
  "components": {
    "memory": {
      "provider": "mempalace",
      "mode": "spatial",
      "external": true
    }
  },
  "mcp": {
    "available": true,
    "server": "mempalace",
    "entryPoint": "mempalace-mcp",
    "installCommand": "mempalace-mcp --palace /path/to/palace"
  },
  "providers": [
    {
      "id": "mempalace",
      "type": "memory",
      "mode": "read-write",
      "protocol": "mcp",
      "capabilities": ["spatial-memory", "durable-context", "agent-learning-trails"]
    }
  ]
}
Memory plugins with "protocol": "mcp" connect to an MCP server. Squad records the metadata and configuration but does not manage the lifecycle of the external server — you start it separately and Squad uses it via MCP.

​
Managing the Marketplace

The squad plugin marketplace subcommand manages which plugin sources your project uses: 
# List configured plugin marketplaces
squad plugin marketplace list

# Add a new marketplace source
squad plugin marketplace add <owner/repo>

# Browse available plugins from all configured sources
squad plugin marketplace browse

# Remove a marketplace source
squad plugin marketplace remove <url>
Plugin sources are GitHub repositories (owner/repo) pointing to marketplace index files. Squad fetches the index, lists available plugins, and handles installation into your project’s plugin state.

​
Sample Plugins

The Squad repository ships three sample plugins in samples/ that demonstrate the manifest format and integration patterns:

plugin-knowledge-graphify

Integrates with graphify, a Python code knowledge graph tool. Generates static graph artifacts (graph.json, GRAPH_REPORT.md) that agents can reference to understand code relationships. Runs on onEnable and onMemoryRefresh lifecycle events. No MCP required — uses the static-artifact protocol.

plugin-knowledge-index-server

Integrates with index-server, an MCP instruction index. Provides a governed knowledge catalog for team standards and instructions. Uses the mcp protocol with the query-index tool. Install the server with npx -y @jagilber-org/index-server@latest --dashboard.

plugin-memory-mempalace

Provides a memory-palace-style spatial memory backend. Agents can store and retrieve context organized as rooms, shelves, trails, and landmarks. Uses the mcp protocol. Install the server with mempalace-mcp --palace /path/to/palace.

​
Creating a Plugin

A plugin requires a plugin.manifest.json at its root. The full manifest schema: 
{
  "id": "my-plugin",
  "name": "My Plugin",
  "version": "1.0.0",
  "description": "What this plugin does",
  "authors": ["Your Name"],
  "license": "MIT",
  "squad": ">=0.9.1",
  "components": {
    "knowledge": ["provider-id"],
    "memory": {
      "provider": "provider-id",
      "mode": "read-write",
      "external": true
    }
  },
  "repository": {
    "type": "github",
    "url": "https://github.com/you/my-plugin"
  },
  "upstream": {
    "package": "my-package",
    "registry": "npm",
    "installCommand": "npm install -g my-package",
    "docs": "https://github.com/you/my-plugin"
  },
  "mcp": {
    "available": true,
    "server": "my-server",
    "entryPoint": "my-server-entrypoint",
    "installCommand": "my-server-entrypoint --config ./config.json",
    "reason": "Explain why this uses MCP or why it doesn't"
  },
  "providers": [
    {
      "id": "provider-id",
      "type": "knowledge",
      "mode": "read",
      "protocol": "static-artifact",
      "description": "What this provider does",
      "artifact": "path/to/artifact.md",
      "capabilities": ["capability-one", "capability-two"]
    }
  ],
  "runtime": {
    "capabilities": [
      {
        "type": "artifact-generation",
        "provider": "provider-id",
        "lifecycle": ["onEnable"],
        "outputPaths": ["output/artifact.md"]
      }
    ]
  },
  "files": [
    {
      "source": "local/source.md",
      "target": "installed/target.md",
      "type": "doc"
    }
  ]
}

​
Manifest validation

The SDK exports a validatePluginManifest function you can use to check your manifest before publishing: 
import { validatePluginManifest } from '@bradygaster/squad-sdk';
import { readFileSync } from 'node:fs';

const manifest = JSON.parse(readFileSync('plugin.manifest.json', 'utf-8'));
const result = validatePluginManifest(manifest);

if (!result.valid) {
  console.error('Manifest errors:', result.errors);
} else {
  console.log('Manifest is valid');
}

​
Marketplace manifest

To list your plugin in the marketplace, you also need a MarketplaceManifest — a separate, richer descriptor for discovery: 
import { generateManifest } from '@bradygaster/squad-sdk';

// Generate from your squad.config.ts
const manifest = generateManifest(squadConfig);
// Returns a MarketplaceManifest with name, version, description,
// categories, tags, icon, pricing, and more
Categories available: productivity, development, testing, devops, documentation, security, other.

Build docs developers (and LLMs) love

Get started for freeTalk to us