# LinkedIn Competitor Analysis MCP Server

## Overview
A Model Context Protocol (MCP) server that helps you:
- 📊 Monitor and analyze competitor LinkedIn posts
- 💡 Extract insights and trending ideas
- ✍️ Generate original post concepts for your company
- 🎨 Create graphics-ready content with metadata

## Features
- **Competitor Post Tracking**: Fetch and store LinkedIn posts from competitor accounts
- **AI-Powered Analysis**: Analyze engagement, themes, and content strategies
- **Content Generation**: Create original post ideas inspired by competitor insights
- **Graphics Integration**: Export post concepts with metadata for design tools
- **Trend Detection**: Identify trending topics and content patterns

## Tech Stack
- **Language**: Python 3.10+
- **Framework**: FastAPI
- **LLM Integration**: Anthropic Claude API
- **LinkedIn API**: Official LinkedIn REST APIs
- **Database**: PostgreSQL (optional, with SQLAlchemy)
- **Task Queue**: Celery (for async processing)

## Project Structure
```
linkedin-mcp-server/
├── app/
│   ├── __init__.py
│   ├── main.py                 # FastAPI application
│   ├── config.py               # Configuration & environment
│   ├── auth/
│   │   ├── __init__.py
│   │   └── linkedin_auth.py    # LinkedIn OAuth2 flow
│   ├── services/
│   │   ├── __init__.py
│   │   ├── linkedin_service.py # LinkedIn API interactions
│   │   ├── analysis_service.py # AI analysis of posts
│   │   └── content_service.py  # Post generation & formatting
│   ├── models/
│   │   ├── __init__.py
│   │   └── schemas.py          # Pydantic models
│   ├── routes/
│   │   ├── __init__.py
│   │   ├── competitors.py      # Competitor tracking
│   │   ├── posts.py            # Post analysis
│   │   └── generation.py       # Content generation
│   └── utils/
│       ├── __init__.py
│       └── logger.py
├── tests/
│   ├── __init__.py
│   ├── test_linkedin.py
│   └── test_analysis.py
├── .env.example
├── requirements.txt
├── docker-compose.yml
├── Dockerfile
└── README.md
```

## Setup Instructions

### Prerequisites
- Python 3.10+
- LinkedIn Developer Account (https://www.linkedin.com/developers/)
- Anthropic API Key (https://console.anthropic.com/)
- PostgreSQL (optional)

### 1. Clone & Install
```bash
git clone https://github.com/satvikjain012-cmyk/linkedin-mcp-server.git
cd linkedin-mcp-server
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt
```

### 2. Environment Setup
```bash
cp .env.example .env
```

Edit `.env` with your credentials:
```env
# LinkedIn OAuth
LINKEDIN_CLIENT_ID=your_client_id
LINKEDIN_CLIENT_SECRET=your_client_secret
LINKEDIN_REDIRECT_URI=http://localhost:8000/auth/callback

# Anthropic
ANTHROPIC_API_KEY=your_api_key

# Database (optional)
DATABASE_URL=postgresql://user:password@localhost/linkedin_mcp

# Server
SERVER_HOST=0.0.0.0
SERVER_PORT=8000
```

### 3. Run the Server
```bash
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
```

Server will be available at `http://localhost:8000`

## API Endpoints

### Authentication
- `GET /auth/linkedin` - Initiate LinkedIn OAuth flow
- `GET /auth/callback` - OAuth callback handler
- `POST /auth/logout` - Logout and revoke token

### Competitors
- `POST /competitors` - Add competitor to track
- `GET /competitors` - List tracked competitors
- `DELETE /competitors/{id}` - Remove competitor

### Posts
- `GET /posts/competitor/{competitor_id}` - Fetch competitor's recent posts
- `POST /posts/analyze` - Analyze a post or set of posts
- `GET /posts/trending` - Get trending topics from competitor posts

### Content Generation
- `POST /generate/post-idea` - Generate original post based on competitors
- `POST /generate/with-graphics-brief` - Generate post with graphics specifications
- `GET /generate/history` - View generation history

## Usage Example

### 1. Add Competitors to Track
```bash
curl -X POST http://localhost:8000/competitors \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {token}" \
  -d '{
    "name": "Competitor Name",
    "linkedin_url": "https://www.linkedin.com/company/competitor",
    "industry": "Tech"
  }'
```

### 2. Fetch & Analyze Their Posts
```bash
curl -X GET http://localhost:8000/posts/competitor/1 \
  -H "Authorization: Bearer {token}"
```

### 3. Generate Original Content
```bash
curl -X POST http://localhost:8000/generate/post-idea \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {token}" \
  -d '{
    "competitor_ids": [1, 2, 3],
    "topics": ["AI", "automation"],
    "tone": "professional",
    "company_context": "Our company specializes in..."
  }'
```

### 4. Generate Post with Graphics Metadata
```bash
curl -X POST http://localhost:8000/generate/with-graphics-brief \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer {token}" \
  -d '{
    "post_idea": "generated_post_id",
    "design_preferences": {
      "colors": ["#FF6B6B", "#4ECDC4"],
      "style": "modern",
      "include_stats": true
    }
  }'
```

## Workflow

```
1. Authenticate with LinkedIn OAuth
   ↓
2. Add competitors you want to track
   ↓
3. Fetch their recent posts (manual or auto-sync)
   ↓
4. AI analyzes posts for:
   - Engagement patterns
   - Content themes
   - Trending topics
   - Audience sentiment
   ↓
5. Generate original post ideas inspired by insights
   ↓
6. Export with graphics specifications (colors, layout, stats)
   ↓
7. Share with design team or graphics tool
```

## Configuration

See `config.py` for all available settings:
- API rate limiting
- Cache expiration
- LLM model selection
- Post analysis depth

## Contributing

Pull requests welcome! Please:
1. Fork the repository
2. Create a feature branch
3. Submit a PR with tests

## License
MIT

## Support
For issues or questions, open a GitHub issue or contact the maintainer.