Cursor rule

1---
2description: Require using Context7 or Web Search to review library documentation before implementation
3globs: **/*
4alwaysApply: true
5---
6 
7# External Library Documentation Requirements
8 
9- **ALWAYS Use Context7 Before Using External Libraries**
10 
11  - The agent MUST retrieve and review documentation via Context7 before implementing any code that uses an external library
12  - This applies to ALL libraries not part of the standard language libraries
13  - No exceptions - even for commonly known libraries like React, Express, or Lodash
14 
15- **Two-Step Documentation Retrieval Process**
16 
17```javascript
18  // ✅ DO: ALWAYS follow this exact two-step process
19  // Step 1: Resolve the library name to a Context7-compatible ID
20  const libraryIdResponse =
21    await mcp_context7_resolve-library-id({
22      libraryName: "express",
23    });
24 
25  // Step 2: Get the documentation using the resolved ID
26  const docsResponse =
27    await mcp_context7_get-library-docs({
28      context7CompatibleLibraryID: libraryIdResponse.libraryId,
29      tokens: 10000, // Adjust based on documentation needs
30      topic: "routing", // Optional: focus on specific area
31    });
32 
33  // ❌ DON'T: Skip the resolution step
34  // ❌ DON'T: Use hardcoded library IDs
35  // ❌ DON'T: Proceed with implementation without review
36```
37 
38- **Never Skip Documentation Retrieval**
39 
40  - Documentation MUST be retrieved even for seemingly simple APIs
41  - Do not rely on previously cached knowledge for current implementations
42  - Never make assumptions about library interfaces, verify with current documentation
43 
44- **Document First, Implement Second**
45 
46```javascript
47  // ✅ DO: Review documentation BEFORE writing implementation code
48  // 1. Identify library need
49  // 2. Retrieve documentation
50  // 3. Review relevant sections
51  // 4. THEN implement solution
52 
53  // ❌ DON'T: Implementation without documentation
54  const app = express(); // WRONG - Documentation not retrieved first
55  app.get("/", (req, res) => res.send("Hello"));
56```
57 
58- **Verify API Compatibility**
59 
60  - Always check current API version compatibility
61  - Validate method signatures against retrieved documentation
62  - Verify required dependencies and peer dependencies
63 
64- **Handle Documentation Response Properly**
65 
66```javascript
67  // ✅ DO: Properly handle the documentation response
68  const docsResponse =
69    await mcp_context7_get-library-docs({
70      context7CompatibleLibraryID: "vercel/nextjs",
71    });
72 
73  // Extract relevant information
74  const sections = docsResponse.content.sections;
75  const examples = sections.filter((s) => s.type === "example");
76  const apiDocs = sections.filter((s) => s.type === "api");
77 
78  // Use this for implementation guidance
79  // ...
80 
81  // ❌ DON'T: Ignore retrieved documentation
82  // ❌ DON'T: Proceed with implementation based on assumptions
83```
84 
85- **Required Documentation Review Checklist**
86 
87  - Core API functions and methods must be verified
88  - Method signatures and parameters must be validated
89  - Return values and types must be confirmed
90  - Required configuration must be identified
91  - Common patterns and examples must be analyzed
92 
93- **Example Implementation Flow**
94 
95```javascript
96  // ✅ DO: Follow this implementation flow
97 
98  // 1. Identify need for external library
99  // "I need to implement JWT authentication in Express"
100 
101  // 2. Resolve library IDs for ALL needed libraries
102  const expressLibrary =
103    await mcp_context7_resolve-library-id({
104      libraryName: "express",
105    });
106 
107  const jwtLibrary =
108    await mcp_context7_resolve-library-id({
109      libraryName: "jsonwebtoken",
110    });
111 
112  // 3. Retrieve documentation for ALL libraries
113  const expressDocs =
114    await mcp_context7_get-library-docs({
115      context7CompatibleLibraryID: expressLibrary.libraryId,
116    });
117 
118  const jwtDocs =
119    await mcp_context7_get-library -
120    docs({
121      context7CompatibleLibraryID: jwtLibrary.libraryId,
122      topic: "authentication",
123    });
124 
125  // 4. Review documentation and extract implementation details
126  // 5. Create implementation with proper reference to documentation
127 
128  // ❌ DON'T: Skip any library in multi-library implementations
129```
130 
131- **Documentation First for Dependency Resolution**
132 
133  - All transitive dependencies must be documented
134  - Version compatibility must be verified
135  - Properly handle conflicting dependencies
136 
137- **Update Implementation After Documentation Review**
138 
139```javascript
140  // ✅ DO: Update existing code based on documentation
141  // If reviewing code that uses libraries without proper documentation:
142 
143  // 1. Retrieve documentation for used libraries
144  // 2. Verify existing implementation against documentation
145  // 3. Correct any discrepancies found
146 
147  // ❌ DON'T: Assume existing implementation is correct
148  // ❌ DON'T: Skip verification of existing library usage
149```
150 
151- **MUST Use Web Search When Documentation Is Unavailable**
152 
153  - If Context7 cannot provide documentation or returns insufficient information, the agent MUST use the web search tool
154  - Always search for the most recent documentation as of mid-2025
155  - Verify the library version against the latest available release
156 
157```javascript
158  // ✅ DO: Fallback to web search when Context7 fails
159  try {
160    // First attempt to use Context7
161    const libraryIdResponse =
162      (await mcp_context7_resolve-library-id({
163        libraryName: "some-library",
164      });
165 
166    const docsResponse =
167      (await mcp_context7_get-library-docs({
168        context7CompatibleLibraryID: libraryIdResponse.libraryId,
169      });
170 
171    // Check if documentation is insufficient
172    if (!docsResponse.content || docsResponse.content.length < 100) {
173      throw new Error("Insufficient documentation");
174    }
175  } catch (error) {
176    // If Context7 fails or returns insufficient docs, use web search
177    const webResults = await web_search({
178      search_term: "some-library latest documentation api reference mid 2025",
179      explanation: "Context7 documentation was unavailable or insufficient",
180    });
181 
182    // Analyze multiple search results to get comprehensive information
183    const latestDocs = webResults.filter(
184      (result) =>
185        result.includes("documentation") ||
186        result.includes("api reference") ||
187        result.includes("guide")
188    );
189 
190    // Use these web results to guide implementation
191  }
192 
193  // ❌ DON'T: Skip web search when Context7 fails
194  // ❌ DON'T: Proceed with implementation without documentation
195  // ❌ DON'T: Use outdated web search results (verify they're current as of mid-2025)
196```
197 
198- **Web Search Requirements**
199 
200  - Search queries MUST include:
201    - Library name
202    - "latest documentation" or "api reference"
203    - Version information (if known)
204    - "mid 2025" to get the most recent documentation
205  - Multiple searches may be needed to gather comprehensive information
206  - Verify information from at least 2-3 reputable sources when possible
207  - Consider official documentation, GitHub repositories, and trusted developer resources
208 
209- **Synthesize Documentation From Multiple Sources**
210 
211  - When using web search, compile information from multiple sources
212  - Prioritize official documentation sources
213  - Cross-reference information to ensure accuracy
214  - Document any discrepancies found between sources
215 
216```javascript
217  // ✅ DO: Synthesize documentation from multiple sources
218  const webResults = [
219    await web_search({
220      search_term: "library-name official documentation mid 2025",
221      explanation: "Finding official documentation",
222    }),
223    await web_search({
224      search_term: "library-name GitHub README api reference mid 2025",
225      explanation: "Finding GitHub documentation",
226    }),
227    await web_search({
228      search_term: "library-name latest tutorial examples mid 2025",
229      explanation: "Finding practical examples",
230    }),
231  ];
232 
233  // Analyze and synthesize the results
234  // Extract API details, examples, and best practices
235  // Document any conflicting information
236 
237  // ❌ DON'T: Rely on a single search result
238  // ❌ DON'T: Skip verification across multiple sources
239```
240