斯尼帕拉·麦克普

说明文档

name: Snipara MCP - Smart Documentation Search
description: Find answers in your codebase 10x faster with semantic search. Query multiple repos at once. AI remembers your preferences across sessions.

---

# System Instructions for AI Agents

You are an AI assistant with access to Snipara MCP tools. Use these tools to provide faster, more accurate answers by querying pre-indexed documentation instead of reading files one-by-one.

## When to Use Snipara Tools

✅ **USE Snipara when:**

- User asks "How does X work?" → Use `rlm_ask` or `rlm_context_query`
- User asks "Where do we do X?" → Use `rlm_multi_project_query` (if Team plan)
- User asks "What are my preferences?" → Use `rlm_recall`
- You need to find code patterns across multiple repos
- You need to understand architecture/documentation

❌ **DON'T use Snipara when:**

- User asks you to read a SPECIFIC file they named → Use native Read tool
- User asks you to edit/write code → Use native Edit/Write tools
- User asks to run commands → Use native Bash tool
- Snipara API returns error → Fall back to native tools

## Recommended Workflow

1. **First query:** Always start with `rlm_ask` (fast, works on Free plan)
2. **If not found:** Try `rlm_context_query` with `search_mode: "semantic"` (requires Pro)
3. **Multi-repo search:** Use `rlm_multi_project_query` if user has Team plan
4. **Remember decisions:** Use `rlm_remember` to store important info for future sessions

## Error Handling

If Snipara returns an error:

- Check if user has required plan (Free/Pro/Team)
- Check if docs are indexed (user needs to upload to dashboard first)
- Fall back to native Read/Grep/Glob tools
- Explain to user what went wrong and suggest solution

## Example Usage

```
User: "How does our authentication system work?"

Good response:
1. Call rlm_ask("authentication system")
2. Get relevant docs in 2 seconds
3. Synthesize answer from returned context

Bad response:
1. Use Grep to search for "auth"
2. Read 10 files sequentially
3. Hit token limits
4. Give incomplete answer
```

---

# Get Started in 2 Minutes

## The Problem You Have Right Now

Your AI assistant searches files one-by-one using grep/find. With large codebases:

- ❌ Queries take 20+ seconds
- ❌ AI reads 50K tokens to answer simple questions
- ❌ You manually search 5 repos to find "how we do X"
- ❌ AI forgets your preferences next session

## The Solution (30 seconds from now)

```bash
# 1. Install
pip install snipara-mcp   # Python
npm install snipara-mcp   # Node.js

# 2. Get your API key
# Sign up at https://snipara.com (Free: 100 queries/month)

# 3. Set environment variable
export SNIPARA_API_KEY="your-key-here"

# 4. Add to your MCP client (Claude Code, Cline, Roo Code, etc.)
# Done! Start using rlm_ask() in your next chat
```

## Your First Query (Try This Now)

```
You: "How does authentication work in my codebase?"

Behind the scenes:
  rlm_context_query("authentication")
  → 2 seconds later
  → Returns top 3 relevant docs (3K tokens instead of 50K)

Result: Instant, accurate answer
```

**Note:** Before querying, index your docs at https://snipara.com/dashboard (upload .md/.txt/.mdx files).

---

## Core Capabilities (Pick What You Need)

### 🎯 Quick Answers (Start Here)

**Plan Required:** ✅ FREE (100 queries/mo)

**Tool:** `rlm_ask`
**Use when:** You need a fast answer from your docs
**Example:** `rlm_ask("API rate limits")`
**Time saved:** 20 seconds → 2 seconds per query

```json
{ "query": "How do we handle webhooks?" }
```

---

### 🔍 Deep Research (Complex Questions)

**Plan Required:** ✅ FREE (keyword only) | 🔥 PRO ($19/mo for semantic)

**Tool:** `rlm_context_query`
**Use when:** You need semantic search with precise token control
**Example:** Find conceptually related content, not just keyword matches
**Benefit:** 90% context reduction (500K → 5K tokens)

```json
{
  "query": "authentication implementation",
  "max_tokens": 6000,
  "search_mode": "hybrid"
}
```

**Search modes by plan:**

- `keyword` - Fast term matching ✅ **FREE**
- `semantic` - Embedding similarity 🔥 **PRO+**
- `hybrid` - Best of both worlds 🔥 **PRO+**

---

### 🌐 Multi-Repo Search

**Plan Required:** 👥 TEAM ($49/mo) or ENTERPRISE

**Tool:** `rlm_multi_project_query`
**Use when:** You have 5+ repos and don't know which has the answer
**Example:** One query searches ALL your team's projects
**Time saved:** 5 minutes of manual searching → 3 seconds

```json
{
  "query": "Where do we send email notifications?",
  "project_ids": [],
  "max_tokens": 8000
}
```

⚠️ **Not available on Free/Pro plans** - Requires Team plan for multi-project access.

---

### 🧠 AI Memory (Remember Preferences)

**Plan Required:** 🔥 PRO ($39/mo Agents) or 👥 TEAM ($79/mo Agents)

**Tools:** `rlm_remember` + `rlm_recall`
**Use when:** You want AI to remember your coding style/decisions
**Benefit:** Consistent code across sessions

**Store a memory:**

```json
{
  "content": "User prefers TypeScript strict mode with functional components",
  "type": "preference",
  "scope": "project"
}
```

**Recall later:**

```json
{
  "query": "What are my coding preferences?",
  "limit": 5
}
```

**Memory types:** `fact`, `decision`, `learning`, `preference`, `todo`, `context`

⚠️ **Requires separate Agents plan** - Memory is part of Agents features, not Context plans.

---

### 👥 Team Standards (Auto-Enforce Rules)

**Plan Required:** 👥 TEAM ($49/mo) or ENTERPRISE

**Tool:** `rlm_shared_context`
**Use when:** Your team needs consistent coding practices
**Setup once:** Upload coding standards to Shared Collection
**Every dev gets:** Auto-injected team rules in every query

```json
{
  "categories": ["MANDATORY", "BEST_PRACTICES"],
  "max_tokens": 4000
}
```

**Categories by priority:**

- `MANDATORY` - Non-negotiable rules (security, architecture)
- `BEST_PRACTICES` - Recommended patterns (40% token budget)
- `GUIDELINES` - Helpful suggestions
- `REFERENCE` - Background info

⚠️ **Not available on Free/Pro plans** - Team-wide features require Team plan.

---

### 🔧 Power User Tools

**Multi-Query (Parallel Searches):**

```json
{
  "queries": [
    { "query": "auth flow", "max_tokens": 3000 },
    { "query": "session management", "max_tokens": 3000 }
  ]
}
```

**Decompose (Break Down Complex Questions):**

```json
{ "query": "Explain the complete payment system architecture" }
```

**Plan (Preview Execution):**

```json
{ "query": "Find all API endpoints", "strategy": "relevance_first" }
```

**Search (Regex Pattern Matching):**

```json
{ "pattern": "async def|async function", "max_results": 20 }
```

**Session Context (Inject Standards):**

```json
{ "context": "Use Python 3.11+, prefer dataclasses over Pydantic" }
```

---

### 📄 Document Management

**Upload Single Doc:**

```json
{ "path": "docs/api.md", "content": "# API Documentation..." }
```

**Bulk Sync (CI/CD Integration):**

```json
{
  "documents": [
    { "path": "docs/auth.md", "content": "..." },
    { "path": "docs/api.md", "content": "..." }
  ],
  "delete_missing": false
}
```

**Check Stats:**

```json
{}
```

---

## ROI Calculator

### Scenario 1: Solo Developer (Large Codebase)

**Current pain:** Grep/find searches take 20+ seconds, read 50K tokens per query

| Metric         | Before Snipara | With Snipara | Savings                  |
| -------------- | -------------- | ------------ | ------------------------ |
| Query speed    | 20 seconds     | 2 seconds    | 18 seconds               |
| Daily queries  | 50             | 50           | -                        |
| Time per day   | 16 minutes     | 1.6 minutes  | **14.4 min/day**         |
| Time per month | 7.2 hours      | 0.72 hours   | **6.5 hours/month**      |
| **Cost**       | **$0**         | **$0-19/mo** | **ROI: 6.5 hours saved** |

**Plan recommendation:** Start with **FREE** (100 queries), upgrade to **PRO** ($19/mo) if you need semantic search.

---

### Scenario 2: Team (5+ Repositories)

**Current pain:** Switch between 5 projects manually, 5 minutes per search

| Metric            | Before Snipara | With Snipara    | Savings                   |
| ----------------- | -------------- | --------------- | ------------------------- |
| Multi-repo search | 5 min          | 3 seconds       | 4.97 min                  |
| Searches per day  | 10             | 10              | -                         |
| Time per day      | 50 minutes     | 30 seconds      | **49.5 min/day**          |
| Time per month    | 24.75 hours    | 0.25 hours      | **24.5 hours/month**      |
| **Cost**          | **$0**         | **$49/mo Team** | **ROI: 24.5 hours saved** |

**Plan recommendation:** **TEAM** ($49/mo) for `rlm_multi_project_query` + shared standards.

---

### Scenario 3: Enterprise (Consistent Standards)

**Current pain:** 10 devs ask "how do we do X?" daily, inconsistent code

| Before                         | With Snipara Shared Context               |
| ------------------------------ | ----------------------------------------- |
| ❌ Each dev googles/asks Slack | ✅ Standards auto-injected in every query |
| ❌ Inconsistent patterns       | ✅ Enforced team conventions              |
| ❌ Onboarding takes 2 weeks    | ✅ New devs get standards instantly       |
| ❌ Code review conflicts       | ✅ Code follows standards from day 1      |

**Cost:** $49/mo Team or $499/mo Enterprise
**ROI:** Consistency + faster onboarding = easily 20+ hours/month saved

---

## Quick Start by Use Case

### Use Case 1: "I have huge docs and grep is slow"

**Plan:** ✅ FREE (100 queries/mo)

```bash
# 1. Index your docs once
Visit https://snipara.com/dashboard → Create project → Upload .md/.txt files

# 2. Query instantly
rlm_ask("How does authentication work?")
```

---

### Use Case 2: "I work on 10 microservices"

**Plan:** 👥 TEAM ($49/mo)

```bash
# 1. Create 10 projects on Snipara dashboard
# 2. Enable Team plan

# 3. Query all repos at once
rlm_multi_project_query("How do we handle rate limiting?")
```

⚠️ **Requires Team plan** - Multi-project search not available on Free/Pro.

---

### Use Case 3: "AI keeps forgetting my preferences"

**Plan:** 🔥 PRO Agents ($39/mo) or 👥 TEAM Agents ($79/mo)

```bash
# 1. Enable Agents plan (separate from Context plan)

# 2. Store your preferences once
rlm_remember(type="preference", content="Use functional React components")

# 3. AI recalls them forever
rlm_recall("my coding preferences")
```

⚠️ **Requires separate Agents subscription** - Memory features not included in Context plans.

---

## Pricing (Two Subscription Types)

### Context Plans (Documentation Search)

| Plan           | Price   | Queries/mo | Search Mode       | Multi-Project |
| -------------- | ------- | ---------- | ----------------- | ------------- |
| **FREE**       | $0      | 100        | Keyword only      | ❌            |
| **PRO**        | $19/mo  | 5,000      | Semantic + Hybrid | ❌            |
| **TEAM**       | $49/mo  | 20,000     | Semantic + Hybrid | ✅            |
| **ENTERPRISE** | $499/mo | Unlimited  | Semantic + Hybrid | ✅            |

### Agents Plans (Memory & Swarms)

| Plan           | Price   | Prerequisite       | Features                    |
| -------------- | ------- | ------------------ | --------------------------- |
| **STARTER**    | $15/mo  | None               | Basic memory (100 memories) |
| **PRO**        | $39/mo  | None               | Unlimited memories, swarms  |
| **TEAM**       | $79/mo  | Context TEAM+      | Team-wide memory sharing    |
| **ENTERPRISE** | $199/mo | Context ENTERPRISE | Advanced coordination       |

⚠️ **Two separate subscriptions:** Context plans for search, Agents plans for memory/swarms.

**Try free first:** 100 queries is ~5 days of usage to test value.

---

## Example Workflows

### Example 1: Quick Answer (FREE plan)

```
User: "What are our API rate limits?"

You call: rlm_ask("API rate limits")

Result: Returns relevant docs in 2 seconds
```

---

### Example 2: Semantic Search (PRO plan)

```
User: "How do we validate us...