ask-mcp

Original：🇺🇸 English

Translated

Query Light Protocol and related repositories via DeepWiki MCP. Use when answering questions about compressed accounts, Light SDK, Solana development, Claude Code features, or agent skills. Triggers on technical questions requiring repository context.

2installs

Sourcelightprotocol/skills

Added on2026-02-25

NPX Install

npx skill4agent add lightprotocol/skills ask-mcp

SKILL.md Content

View Translation Comparison →

DeepWiki Research

Query repositories via DeepWiki MCP to answer technical questions with precise, source-backed answers.

Workflow

Clarify intent
- Recommend plan mode, if it's not activated
- Use
```
AskUserQuestion
```
  to resolve blind spots
- All questions must be resolved before execution
Identify references and skills
- Match task to execution steps below
- Locate relevant documentation and examples
Write plan file (YAML task format)
- Use
```
AskUserQuestion
```
  for anything unclear — never guess or assume
- Identify blockers: permissions, dependencies, unknowns
- Plan must be complete before execution begins
Execute
- Use
```
Task
```
  tool with subagents for parallel research
- Subagents load skills via
```
Skill
```
  tool
- Track progress with
```
TodoWrite
```
When stuck: spawn subagent with
```
Read
```
,
```
Glob
```
,
```
Grep
```
, DeepWiki MCP access and load
```
skills/ask-mcp
```

Execution Steps

1. Read Required Context in Local Repo

Use

/init

skill and index current repository, if you have not already

2. Identify Question Scope

Determine the domain:

Programs, client SDKs, architecture, implementation details
Specific components (LightAccount, ValidityProof, CPI, etc.)

2. Fetch Repository Context

Select the appropriate repository based on question scope:

Light Protocol (compressed accounts, state trees, ZK compression, Light SDK)

mcp__deepwiki__read_wiki_structure("Lightprotocol/light-protocol")
mcp__deepwiki__read_wiki_contents("Lightprotocol/light-protocol")
mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "your question")

Solana Development (programs, accounts, general Solana)

mcp__deepwiki__read_wiki_structure("blueshift-gg/blueshift-dashboard")
mcp__deepwiki__read_wiki_contents("blueshift-gg/blueshift-dashboard")
mcp__deepwiki__ask_question("blueshift-gg/blueshift-dashboard", "your question")

Claude Code (CLI features, commands, configuration)

mcp__deepwiki__read_wiki_structure("anthropics/claude-code")
mcp__deepwiki__read_wiki_contents("anthropics/claude-code")
mcp__deepwiki__ask_question("anthropics/claude-code", "your question")

Agent Skills (skills, subagents, patterns)

mcp__deepwiki__read_wiki_structure("anthropics/skills")
mcp__deepwiki__read_wiki_contents("anthropics/skills")
mcp__deepwiki__ask_question("anthropics/skills", "your question")

### 3. Apply Precision Rules

**AVOID:**
- Vague verbs: "handles", "manages", "processes", "enables", "provides"
- Abstract nouns: "operations", "management", "coordination"
- -ing endings when a precise verb exists
- Marketing language: "comprehensive", "rich", "seamless",  "enables", "provides capability"
- ZK terminology in user-facing docs: "inclusion proof", "non-inclusion proof" → Instead describe what it does: "prove the address doesn't exist", "prove the account hash exists"
- Generic descriptions: "account metadata" instead of "CompressedAccountMeta"


**USE:**
- Exact function/method names
- Concrete data structures
- Specific operations: "sets discriminator", "creates hash", "nullifies account"
- File:line references
- "reference" when describing u8 indices that reference accounts in the accounts array (standard Solana terminology)
- "CPI" as a verb (e.g., "CPIs the Account Compression Program")
- Technical method/function names used as verbs when contextually clear

`Describe exactly what happens.`

### 4. Format Response

Structure answers with:
- Technical precision
- Code examples with inline comments
- Source references (file paths, line numbers)

## Example Output

**Question:** What do you include in instruction data for compressed account creation?

**Answer:**

---

## Compressed Account Creation Instruction Data

Instruction data contains three components for proof verification and tree coordination.

**Components:**

```rust
pub struct InstructionData {
    proof: ValidityProof,
    address_tree_info: PackedAddressTreeInfo,
    output_state_tree_index: u8,
    // + custom account data
}

1. Non-inclusion proof

```
ValidityProof
```
proves the derived address does not exist in the specified address tree
Client generates via
```
getValidityProof()
```
RPC call

2. Tree location parameters

```
PackedAddressTreeInfo
```
: Specifies which address tree registers the address (u8 index, not pubkey)
```
output_state_tree_index
```
: Specifies which state tree stores the compressed account hash

3. Custom account data

Program-specific fields (e.g.,
```
message: String
```
, user data)

Execution flow:

Address tree proves uniqueness, stores address
State tree stores account hash
ValidityProof cryptographically guarantees address is unused

Why separate trees:

Compressed accounts require client-generated cryptographic proof that address doesn't exist (unlike regular Solana where runtime checks PDA existence). Address trees enforce uniqueness; state trees store account hashes.

Packed structs use

u8

indices to reference accounts in

remaining_accounts

, reducing transaction size.