> ## Documentation Index
> Fetch the complete documentation index at: https://docs.anysite.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Cursor MCP Tool Examples
> Practical examples and workflows using Anysite MCP in Cursor IDE
## Overview
This guide demonstrates practical workflows and examples for using Anysite MCP tools with Cursor IDE. These examples show how to leverage the AI-powered IDE integration for development, research, and data-driven coding.
## Basic Usage
### Starting with MCP in Cursor
Once configured, simply open Cursor and start a chat with the AI assistant:
```
What MCP tools do I have access to?
```
Cursor AI will list all available Anysite tools from the connected MCP server.
### Quick Data Extraction
**Example: LinkedIn Profile Analysis**
In Cursor AI Chat, type:
```
Extract information from this LinkedIn profile:
https://linkedin.com/in/satyanadella
Focus on:
- Current role and company
- Career progression
- Education background
```
Cursor will use the `linkedin_user` MCP tool to fetch and analyze the data.
***
## Development Workflows
### Workflow 1: Building a Sales Intelligence Feature
**Scenario:** You're building a CRM feature that needs LinkedIn data enrichment.
**Step 1: Define the data model**
In Cursor AI:
```
I'm building a lead enrichment feature. Extract data from this LinkedIn profile
and suggest a TypeScript interface based on the available data:
https://linkedin.com/in/example-profile
```
**Step 2: Generate the code**
```
Using the LinkedIn data structure we just saw, create a TypeScript service
that fetches and transforms LinkedIn data for our CRM.
Include error handling and rate limiting.
```
**Step 3: Test with real data**
```
Test the service by extracting data from these profiles:
- linkedin.com/in/profile1
- linkedin.com/in/profile2
Validate that the response matches our interface.
```
### Workflow 2: Competitive Analysis Tool
**Project setup:**
```
my-competitor-tool/
├── .cursor/
│ └── mcp.json # MCP configuration
├── src/
│ ├── analyzers/
│ │ └── company.ts
│ └── types/
│ └── linkedin.ts
└── package.json
```
**In Cursor AI Chat:**
```
I'm building a competitor analysis tool. For these companies:
- https://linkedin.com/company/competitor1
- https://linkedin.com/company/competitor2
Extract:
1. Employee count and growth
2. Recent job postings
3. Key executives
Then generate TypeScript code to fetch and compare this data periodically.
```
### Workflow 3: Lead Scoring System
**Define scoring criteria:**
```
I'm building a lead scoring system. For this LinkedIn profile:
https://linkedin.com/in/potential-lead
Extract relevant data and suggest scoring criteria based on:
- Seniority level
- Company size
- Industry relevance
- Engagement signals
Then create a TypeScript function that scores leads.
```
***
## Real-time Data in Code
### Example 1: Dynamic Data Fetching
**In your project, ask Cursor:**
```
I need to fetch LinkedIn company data dynamically in my Node.js app.
Extract sample data from https://linkedin.com/company/target-company
and create an API endpoint that returns this structure.
```
**Cursor generates:**
```typescript theme={null}
// src/api/company.ts
import { Router } from 'express';
interface LinkedInCompany {
name: string;
industry: string;
size: string;
location: string;
description: string;
employeeCount: number;
// ... based on extracted data
}
const router = Router();
router.get('/company/:slug', async (req, res) => {
const { slug } = req.params;
// MCP tool integration would go here
const companyData = await fetchLinkedInCompany(slug);
res.json(companyData);
});
export default router;
```
### Example 2: Data Validation
**Validate your data models against real data:**
```
Compare this TypeScript interface with actual LinkedIn profile data:
interface UserProfile {
name: string;
headline: string;
location: string;
experience: Experience[];
}
Extract data from linkedin.com/in/test-profile and identify any missing fields.
```
### Example 3: Generate Test Fixtures
```
Extract real data from these profiles:
- linkedin.com/in/engineer-profile
- linkedin.com/in/manager-profile
- linkedin.com/in/executive-profile
Generate TypeScript test fixtures that represent typical data variations.
```
***
## Multi-Platform Research
### Combining Data Sources
**Research a person across platforms:**
```
Research this person comprehensively:
- LinkedIn: linkedin.com/in/target-person
- Instagram: @target_person (if available)
- Reddit activity: u/target_person
Compile a unified profile and identify patterns in their online presence.
```
### Monitoring Competitors
```
For competitive intelligence, analyze:
1. Company LinkedIn: linkedin.com/company/competitor
2. Recent Reddit mentions: search "competitor name" in r/industry
Generate a monitoring report and suggest React components to display this data.
```
***
## Code Generation with Live Data
### Generate API Wrappers
```
Extract the full data structure from linkedin.com/in/sample-profile
and generate:
1. TypeScript interfaces for all data types
2. A complete API client class
3. Zod validation schemas
4. Jest test cases with the real data as fixtures
```
### Generate Database Schemas
```
Based on LinkedIn company data from linkedin.com/company/example:
Generate:
1. Prisma schema for storing this data
2. Database migrations
3. CRUD operations
```
### Generate Documentation
```
Using the LinkedIn profile data structure, generate:
1. JSDoc comments for each field
2. API documentation in OpenAPI format
3. README with usage examples
```
***
## Debugging with MCP Data
### Validate API Responses
**When your API isn't returning expected data:**
```
My API is supposed to return LinkedIn-like data. Here's what I'm getting:
[paste your API response]
Compare this to actual LinkedIn data from linkedin.com/in/test-profile
and identify discrepancies.
```
### Debug Data Transformations
```
I'm transforming LinkedIn data but getting unexpected results.
Here's my transformer:
[paste your code]
Fetch fresh data from linkedin.com/in/test-profile and show me
step-by-step how it should be transformed.
```
***
## Advanced Techniques
### Batch Processing Pattern
**For processing multiple profiles:**
```
I need to process 100 LinkedIn profiles. Design a system that:
1. Handles rate limiting
2. Implements retry logic
3. Caches results
4. Reports progress
Start by extracting sample data from these profiles:
- linkedin.com/in/profile1
- linkedin.com/in/profile2
- linkedin.com/in/profile3
```
### Event-Driven Architecture
```
Design an event-driven system for LinkedIn data updates:
1. Fetch initial data from linkedin.com/company/target
2. Create event types for data changes
3. Implement change detection
4. Generate notification handlers
Show me the TypeScript implementation.
```
### Data Pipeline Integration
```
I'm building an ETL pipeline for LinkedIn data. Design:
1. Extraction layer (using MCP tools)
2. Transformation layer (normalize data)
3. Loading layer (to PostgreSQL)
Include error handling and monitoring.
Demonstrate with data from linkedin.com/company/example
```
***
## Best Practices
### 1. Data Model First
Always extract real data before designing your data models:
```
Before I design my database schema, show me the actual data structure
from linkedin.com/in/representative-profile
```
### 2. Incremental Development
Build features incrementally with real data validation:
```
Step 1: Show me LinkedIn profile data structure
Step 2: Generate TypeScript interface
Step 3: Create fetch function
Step 4: Add error handling
Step 5: Test with 3 different profiles
```
### 3. Security Considerations
Always use environment variables for API keys in your `.cursor/mcp.json`
Add `.cursor/mcp.json` to `.gitignore` if it contains API keys
When sharing code or screenshots, mask any personal data from extractions
Design your code to respect API rate limits from the start
### 4. Testing Strategy
```
For my LinkedIn integration tests, I need:
1. Mock data based on real responses (extract from linkedin.com/in/test)
2. Edge case handling (empty profiles, private accounts)
3. Error simulation (rate limits, network failures)
Generate comprehensive test suite.
```
***
## Common Patterns
### Pattern 1: Profile Enrichment Service
```typescript theme={null}
// Ask Cursor to generate based on real data extraction
class ProfileEnrichmentService {
async enrich(linkedinUrl: string): Promise {
// Implementation with MCP tool integration
}
}
```
**In Cursor:**
```
Extract data from linkedin.com/in/sample-profile and complete
this ProfileEnrichmentService class with proper typing and error handling.
```
### Pattern 2: Company Intelligence Dashboard
```
Design a React dashboard that displays:
1. Company overview (extract from linkedin.com/company/target)
2. Employee growth chart
3. Recent updates timeline
4. Key people section
Generate components with TailwindCSS styling.
```
### Pattern 3: Lead Qualification Workflow
```
Build a lead qualification workflow that:
1. Takes a LinkedIn URL input
2. Extracts profile data
3. Scores based on criteria
4. Returns qualification result
Test with linkedin.com/in/potential-lead
```
***
## Troubleshooting
**Solutions:**
* Reload Cursor window (Cmd/Ctrl + Shift + P → "Reload Window")
* Verify `.cursor/mcp.json` syntax is valid
* Check that Node.js is installed
* Ensure API key is correct
**Solutions:**
* Check your internet connection
* Verify API rate limits in Anysite dashboard
* Consider caching frequently accessed data
* Use batch requests when possible
**Solutions:**
* Always extract fresh data before defining types
* Use runtime validation (Zod, io-ts)
* Handle optional fields gracefully
* Log raw responses during development
**Solutions:**
* Regenerate key from Anysite dashboard
* Check for extra whitespace in config
* Verify subscription is active
* Test with direct API call first
***
## Resources
* [Installation Guide](/mcp-server/cursor-tool/installation)
* [View All MCP Tools](/mcp-server/tools)
* [Compare with Claude Code](/mcp-server/claude-code-tool/installation)
* [Cursor Documentation](https://docs.cursor.com)
## Need Help?
Contact our support team for assistance with Cursor MCP workflows