Architecture

The LookC MCP server follows a clean, lightweight architecture designed for reliability and ease of integration.

Overview

The LookC MCP server is built as a streamlined wrapper around the LookC API, providing a standardized Model Context Protocol interface while maintaining direct access to our comprehensive company research databases.

graph TD
    A[AI Agent/Client] --> B[MCP Protocol Layer]
    B --> C[LookC MCP Server]
    C --> D[Authentication Layer]
    C --> E[Tool Handlers]
    E --> F[LookC API Client]
    F --> G[LookC API]
    G --> H[Company Research Database]

API Wrapper Design

The server architecture prioritizes simplicity and reliability through a direct API wrapper approach:

Minimal Abstraction

Direct mapping between MCP tools and LookC API endpoints ensures predictable behavior and easy debugging.

Transparent Error Handling

API errors are passed through with clear context, making troubleshooting straightforward.

Key Design Principles

Stateless Operation: Each tool call is independent, with no server-side state management
Direct API Mapping: Tool parameters correspond directly to LookC API parameters
Consistent Error Handling: Standardized error responses across all tools
Efficient Data Transfer: Minimal data transformation between API and MCP layers

Tools-Only Implementation

The LookC MCP server implements a tools-only architecture, focusing exclusively on actionable capabilities rather than passive data resources.

Why Tools-Only?

Tools vs Resources: In MCP terminology, tools are functions that can be called to perform actions, while resources are static data that can be read. The LookC server focuses on tools because company research typically requires dynamic queries with specific parameters.

This approach provides several advantages:

Dynamic Queries: Tools accept parameters for filtering, pagination, and search criteria
Real-time Data: Each tool call fetches current data from the LookC API
Flexible Integration: AI agents can compose complex research workflows using tool combinations
Reduced Complexity: No resource management or caching logic required

Available Tool Categories

Employee Research Tools: Query employee lists with advanced filtering
Organization Mapping Tools: Convert between LinkedIn URLs and LookC identifiers
Data Discovery Tools: Explore available data for specific organizations

Authentication Flow

The server implements bearer token authentication with the LookC API:

// Authentication flow
1. Client provides LookC API key during MCP connection
2. Server validates token with LookC API on first request
3. Subsequent requests use cached authentication context
4. Token refresh handled automatically for long-running sessions

Security Considerations

Token Scope: API keys are scoped to specific LookC account permissions
Secure Transport: All communications use HTTPS with TLS 1.3
No Token Storage: Authentication tokens are not persisted server-side
Audit Logging: All API calls are logged for security and debugging purposes

Transport Protocol

The LookC MCP server exclusively uses Streamable HTTP transport for maximum compatibility and reliability.

Why Streamable HTTP?

Universal Compatibility

Works with all HTTP clients and proxy configurations without special setup.

Firewall Friendly

Standard HTTP/HTTPS ports work in corporate environments without additional configuration.

Debugging Support

Standard HTTP tools and debugging proxies work seamlessly for troubleshooting.

Connection Endpoint

# LookC MCP Server Endpoint
https://api.lookc.io/mcp

The server handles MCP protocol negotiation, tool discovery, and execution over this single HTTP endpoint using JSON-RPC 2.0 message format.

Implementation Details

The server is built using FastMCP in Python, chosen for its robust MCP protocol support and active maintenance. This ensures compatibility with the latest MCP specification updates and authentication improvements.

For detailed information about available tools and their parameters, see the Available Tools documentation.