# CanAISeeIt Documentation

## Digital Influence Optimization (DIO)

### Introduction to Digital Influence Optimization

Digital Influence Optimization (DIO) is the practice of optimizing websites and digital content for AI-powered discovery, understanding, and citation. As AI systems increasingly mediate how users find and consume information, DIO ensures your content remains visible and valuable in the age of AI search, conversational AI, and autonomous agents.

Unlike traditional SEO that focuses on search engine rankings, DIO optimizes for:
- AI model comprehension and citation potential
- Structured data interpretation by AI systems
- Bot accessibility for AI crawlers and agents
- Integration with emerging AI protocols and standards
- Content quality that meets AI evaluation criteria

### The DIO Standards Framework

CanAISeeIt evaluates websites against five core DIO standards, each representing critical aspects of AI readiness:

### 1. AI Visibility Standard

**Purpose**: Ensures your content can be discovered, understood, and cited by AI models like GPT-4, Claude, Gemini, and others.

**Evaluation Criteria**:
- **Content Quality Assessment**: AI models evaluate content depth, accuracy, and usefulness
- **Citation Potential**: Likelihood of content being referenced in AI-generated responses
- **Entity Recognition**: How well AI systems can identify and understand key entities in your content
- **AI Impressions**: Cold visibility and brand performance across different AI models and platforms

**Scoring Factors**:
- Semantic content structure and clarity
- Information density and uniqueness
- Authority signals and source credibility
- Topical expertise and depth

**Impact**: Poor AI visibility affects discovery in AI-powered search engines, chatbot responses, and research assistance tools.

### 2. Bot Access Standard

**Purpose**: Verifies that AI crawlers and bots can access and index your website content.

**Evaluation Criteria**:
- **Robots.txt Configuration**: Proper directives for AI-specific user agents
- **Crawler Access Control**: Permissions for major AI crawlers (GPTBot, Claude-Web, PerplexityBot, Google-Extended)
- **JavaScript Renderability**: Content accessibility for AI systems that execute JavaScript
- **Technical Accessibility**: Server response codes, load times, and crawl efficiency

**Critical User Agents Monitored**:
- `GPTBot` - OpenAI's web crawler
- `Claude-Web` - Anthropic's web crawler  
- `PerplexityBot` - Perplexity AI's crawler
- `Google-Extended` - Google's AI training crawler
- `CCBot` - Common Crawl bot used by various AI systems

**Impact**: Blocked or restricted bot access prevents AI systems from including your content in their knowledge base.

### 3. Schema Markup Standard

**Purpose**: Implements structured data that AI systems can easily parse and understand.

**Evaluation Criteria**:
- **JSON-LD Implementation**: Presence and quality of structured data markup
- **Schema Types Coverage**: Appropriate schema.org vocabulary usage
- **Validation Compliance**: Error-free structured data implementation
- **AI-Relevant Schemas**: Focus on schemas that enhance AI understanding

**Priority Schema Types for AI**:
- Organization and ContactPoint
- Article and NewsArticle
- Product and Offer
- FAQ and QAPage
- WebSite and SearchAction
- BreadcrumbList for navigation context

**Impact**: Missing or invalid schema markup reduces AI systems' ability to understand and categorize your content accurately.

### 4. LLMs.txt Protocol Standard

**Purpose**: Provides AI-specific instructions and guidelines for how AI systems should interact with your content.

**Evaluation Criteria**:
- **LLMs.txt Presence**: Implementation of the LLMs.txt file at root level
- **LLMs-full.txt Coverage**: Comprehensive AI interaction guidelines
- **Configuration Quality**: Completeness and clarity of AI directives
- **Permission Clarity**: Clear usage rights and restrictions for AI systems

**LLMs.txt Elements**:
```
# LLMs.txt - AI Interaction Guidelines
User-Agent: *
Allow: /
Disallow: /private/

# Content Usage Guidelines
Citation: preferred
Summarization: allowed
Training: restricted

# Contact Information
Contact: ai-team@example.com
```

**Impact**: Without LLMs.txt, AI systems lack guidance on appropriate content usage and interaction boundaries.

### 5. MCP Protocol Standard

**Purpose**: Enables advanced AI agent integration through the Model Context Protocol.

**Evaluation Criteria**:
- **Well-Known MCP Discovery**: Implementation of `/.well-known/mcp` endpoint
- **HTML Meta Tags**: Proper MCP server advertisement in HTML headers
- **Protocol Headers**: HTTP headers supporting MCP negotiation
- **Tool Availability**: Functional MCP tools and capabilities

**MCP Implementation Levels**:
- **Basic Discovery**: `/.well-known/mcp` endpoint with server information
- **HTML Integration**: Meta tags for automatic MCP server detection
- **Protocol Negotiation**: HTTP headers supporting MCP protocol versions
- **Full Integration**: Complete MCP server with tools and resources

**Example MCP Discovery**:
```json
{
  "version": "1.0",
  "protocol": "mcp",
  "capabilities": {
    "tools": true,
    "resources": true
  },
  "servers": [
    {
      "name": "website-assistant",
      "url": "https://example.com/mcp",
      "capabilities": ["search", "content"]
    }
  ]
}
```

**Impact**: MCP support enables AI agents to interact directly with your website's data and functionality.

### DIO Scoring and Assessment

These attributes are relative to the focus of the platform making use of DIO. Our focus is on relatively equal distribution of each factor to capture a broad picture of DIO.

**Overall DIO Score Calculation**:
- AI Visibility: 25% weight
- Bot Access: 20% weight  
- Schema Markup: 20% weight
- LLMs.txt Protocol: 15% weight
- MCP Protocol: 20% weight

**Score Ranges**:
- **Excellent (80-100)**: Full AI optimization with advanced protocol support
- **Good (60-79)**: Strong foundation with room for advanced features
- **Poor (0-59)**: Significant optimization needed for AI compatibility

**Affected AI Systems by Score Range**:
- **Poor Performance (0-59)**: You may experience limited visibility in models of all types such as GPT, Claude, Gemini, Microsoft Copilot
- **Moderate Performance (60-79)**: You may experience reduced effectiveness with models that prioritize precision and accuracy such as Perplexity
- **Excellent Performance (80-100)**: Good performance across all AI platforms.

### Emerging Terminologies and Related Frameworks

**Generative Engine Optimization (GEO)**:
GEO is an emerging approach that focuses specifically on optimizing content for AI-generated responses and citations. Companies like Anvil and Adobe have introduced specialized tools (such as Adobe LLM Optimizer) that monitor brand visibility across AI-driven platforms and provide recommendations for improving performance in AI-generated outputs.

**Relationship to DIO**:
We view GEO as one of the many focused areas that will emerge within the broader umbrella of Digital Influence Optimization. While some tools specialize towards GEO's specific focus on generative responses, DIO serves a more comprehensive approach by addressing the full spectrum of AI-powered discovery, understanding, and interaction protocols including:

- AI visibility and citation potential (GEO focus area)
- Brand representation monitoring (GEO focus area)
- Bot access and crawler compatibility
- Structured data and schema markup
- AI instruction protocols (LLMs.txt)
- Agentic tooling capabilities (MCP)
- Cross-platform AI compatibility

**Industry Evolution**:
As the AI optimization landscape matures, we expect to see more specialized approaches emerge alongside broader frameworks like DIO. This evolution mirrors the historical development of SEO, which began as a general practice and later spawned specialized sub-disciplines.

### Best Practices

**Content Optimization for AI**:
- Write clear, informative headlines
- Use structured content with proper headings
- Include relevant entities and keywords naturally
- Provide comprehensive, authoritative information
- Maintain factual accuracy and cite sources

**Technical Implementation**:
- Validate all structured data regularly
- Monitor robots.txt compliance
- Test content accessibility for AI crawlers
- Keep protocols updated with latest standards
- Implement comprehensive error handling

**Monitoring and Maintenance**:
- Regular DIO score assessments
- AI crawler log analysis
- Structured data validation
- Protocol compliance checking
- Performance impact measurement

---

## Model Context Protocol (MCP)

### Overview

CanAISeeIt provides MCP (Model Context Protocol) integration for AI agents to analyze websites for optimization opportunities. This service helps AI systems understand how well websites are prepared for AI discovery and interaction.

### Discovery

Access our MCP server configuration at:
```
GET /.well-known/mcp
```

**Response:**
```json
{
  "version": "1.0",
  "protocol": "mcp",
  "capabilities": {
    "tools": true
  },
  "tools": [
    {
      "name": "analyze_website",
      "description": "Analyze a website for AI optimization factors including visibility, bot access, schema markup, and MCP protocol availability",
      "version": "1.0.0"
    },
    {
      "name": "get_analysis_report",
      "description": "Retrieve a specific analysis report by ID",
      "version": "1.0.0"
    },
    {
      "name": "list_recent_reports",
      "description": "List recent analysis reports (authenticated users only)",
      "version": "1.0.0"
    }
  ],
  "authentication": {
    "type": "api_key",
    "header": "Authorization",
    "format": "caisi_*"
  },
  "updatedAt": "2025-06-07"
}
```

### Protocol Details

MCP requests follow the JSON-RPC 2.0 structure, including `id`, `method`, and `params`. Claude Desktop and other MCP clients invoke servers via stdin/stdout, while our HTTP endpoints provide the implementation behind those tools.

### Tool Capabilities Schema

When MCP clients call `tools/list`, they receive detailed metadata:

```json
{
  "tools": [
    {
      "name": "analyze_website",
      "description": "Analyze a website for AI optimization factors including visibility, bot access, schema markup, and MCP protocol availability",
      "inputSchema": {
        "type": "object",
        "properties": {
          "url": {
            "type": "string",
            "description": "Website URL to analyze (must include https:// protocol)",
            "pattern": "^https://.+"
          }
        },
        "required": ["url"]
      }
    },
    {
      "name": "get_analysis_report",
      "description": "Retrieve a specific analysis report by ID",
      "inputSchema": {
        "type": "object",
        "properties": {
          "reportId": {
            "type": "number",
            "description": "Analysis report ID to retrieve"
          }
        },
        "required": ["reportId"]
      }
    },
    {
      "name": "list_recent_reports",
      "description": "Get list of recent analysis reports for the authenticated user",
      "inputSchema": {
        "type": "object",
        "properties": {
          "limit": {
            "type": "number",
            "description": "Maximum number of reports to return (default: 10)",
            "minimum": 1,
            "maximum": 50,
            "default": 10
          }
        }
      }
    }
  ]
}
```

### Available Tools

#### analyze_website
Analyze a website for AI optimization factors including visibility, accessibility, and structured data.

**Endpoint:** `POST /api/mcp/tools/analyze_website`

**Request:**
```json
{
  "url": "https://example.com"
}
```

**Response:**
```json
{
  "success": true,
  "report_id": 123,
  "status": "analysis_started",
  "message": "Website analysis has been initiated"
}
```

#### get_analysis_report
Retrieve a completed analysis report by ID.

**Endpoint:** `POST /api/mcp/tools/get_analysis_report`

**Request:**
```json
{
  "reportId": 123
}
```

**Response:**
```json
{
  "success": true,
  "report": {
    "id": 123,
    "url": "https://example.com",
    "status": "completed",
    "overallScore": 78,
    "recommendations": [...]
  }
}
```

#### list_recent_reports
List recent analysis reports (authenticated users only).

**Endpoint:** `POST /api/mcp/tools/list_recent_reports`

**Request:**
```json
{
  "limit": 10
}
```

### Authentication

MCP access requires API key authentication. Include your API key in the Authorization header:

```
Authorization: caisi_your_api_key_here
```

Create API keys in your dashboard at `/dashboard` → API Keys tab.

### Rate Limits

- Anonymous users: Limited analysis requests
- Authenticated users: Higher limits available
- Rate limits reset daily at midnight UTC

### Usage Example

```bash
# Discover MCP capabilities
curl https://canaiseeit.com/.well-known/mcp

# Start website analysis
curl -X POST https://canaiseeit.com/api/mcp/tools/analyze_website \
  -H "Authorization: caisi_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com"}'

# Get analysis results
curl -X POST https://canaiseeit.com/api/mcp/tools/get_analysis_report \
  -H "Authorization: caisi_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"reportId": 123}'
```

### Error Responses

**Authentication Required (401):**
```json
{
  "error": "API key required",
  "message": "MCP access requires authentication"
}
```

**Rate Limit Exceeded (429):**
```json
{
  "error": "Daily credit limit exceeded",
  "suggestion": "Daily limit resets at midnight UTC"
}
```

**Invalid Request (400):**
```json
{
  "error": "Invalid URL format",
  "message": "Please provide a valid URL including protocol"
}
```

### MCP Client Integration

CanAISeeIt offers two MCP integration methods:

#### Option 1: Remote MCP Server (Recommended)

Connect directly to our hosted MCP server - no local files needed.

**Configuration:**
```json
{
  "mcpServers": {
    "canaiseeit": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch", "https://canaiseeit.com/mcp"],
      "env": {
        "CANAISEEIT_API_KEY": "your_api_key_here"
      }
    }
  }
}
```

**Setup Steps:**
1. Get your API key from [CanAISeeIt Dashboard](https://canaiseeit.com/dashboard) → API Keys tab
2. Add the configuration to your Claude Desktop settings file (see locations below)
3. Replace `your_api_key_here` with your actual API key (starts with `caisi_`)
4. Save the configuration file
5. Restart Claude Desktop

#### Option 2: Local MCP Server

Download and run a local bridge script for offline capability.

**Configuration:**
```json
{
  "mcpServers": {
    "canaiseeit": {
      "command": "node",
      "args": ["/path/to/canaiseeit-mcp-server.cjs"],
      "env": {
        "CANAISEEIT_API_KEY": "your_api_key_here"
      }
    }
  }
}
```

**Setup Steps:**
1. Download the MCP server script: `curl -o canaiseeit-mcp-server.cjs https://canaiseeit.com/canaiseeit-mcp-server.cjs`
2. Get your API key from [CanAISeeIt Dashboard](https://canaiseeit.com/dashboard) → API Keys tab
3. Replace `your_api_key_here` with your actual API key (starts with `caisi_`)
4. Replace `/path/to/canaiseeit-mcp-server.cjs` with the absolute path to your downloaded script
5. Save the configuration file
6. Restart Claude Desktop

#### Configuration File Locations:
- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

**How It Works:**
Claude Desktop MCP will invoke the specified command, passing stdin data matching the JSON-RPC format. The process listens on stdin and returns structured responses on stdout. The command runs as a long-lived process that handles multiple tool requests during the session.

### Platform-Specific Examples

#### Remote MCP Server (All Platforms):
```json
{
  "mcpServers": {
    "canaiseeit": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch", "https://canaiseeit.com/mcp"],
      "env": {
        "CANAISEEIT_API_KEY": "caisi_your_actual_api_key_here"
      }
    }
  }
}
```

#### Local MCP Server:

**macOS/Linux:**
```json
{
  "mcpServers": {
    "canaiseeit": {
      "command": "node",
      "args": ["/Users/yourusername/canaiseeit-mcp-server.cjs"],
      "env": {
        "CANAISEEIT_API_KEY": "caisi_your_actual_api_key_here"
      }
    }
  }
}
```

**Windows:**
```json
{
  "mcpServers": {
    "canaiseeit": {
      "command": "node",
      "args": ["C:\\Users\\YourUsername\\canaiseeit-mcp-server.cjs"],
      "env": {
        "CANAISEEIT_API_KEY": "caisi_your_actual_api_key_here"
      }
    }
  }
}
```

### Troubleshooting

**Claude Desktop Won't Start Server:**
- Validate JSON syntax: Use `json.parser.online.fr` or similar to check your `claude_desktop_config.json`
- Ensure no trailing commas in JSON
- Use absolute paths only (no `~` or `%APPDATA%` variables)
- Check Claude logs at:
  - **macOS**: `~/Library/Logs/Claude/mcp.log`
  - **Windows**: `%LOCALAPPDATA%\Claude\logs\mcp.log`

**Authentication Issues:**
- Ensure API key starts with `caisi_`
- Verify API key is active in your dashboard
- Check environment variable is set correctly
- Test API key with: `curl -H "Authorization: caisi_your_key" https://canaiseeit.com/api/mcp/tools/list_recent_reports`

**MCP Script Issues:**
- Verify Node.js is installed: `node --version`
- Ensure script is executable: `chmod +x canaiseeit-mcp.cjs`
- Test script manually: `echo '{"id":1,"method":"tools/list","params":{}}' | CANAISEEIT_API_KEY=your_key node canaiseeit-mcp.cjs`

**Connection Issues:**
- Verify internet connection to `canaiseeit.com`
- Check firewall settings allow HTTPS requests
- Test connectivity: `curl https://canaiseeit.com/.well-known/mcp`

**Tool Errors:**
- Validate URL format includes `https://` protocol
- Check API rate limits in dashboard
- Verify report IDs exist and belong to your account

### Support

For additional help or to report issues, visit our [dashboard](https://canaiseeit.com/dashboard) or contact support through the website.