Development Tools Integration

Enhance your development environment with LookC company research capabilities through VSCode, Cursor, and other development tools.

Overview

Integrating LookC MCP server with development tools enables developers to access company research data directly within their coding environment, streamlining prospect research, competitive analysis, and customer development workflows.

VSCode Extensions

MCP-compatible extensions for seamless company research within your editor.

Cursor AI Integration

Enhanced AI coding assistance with real-time company data context.

Custom Workflows

Build custom development workflows that incorporate company research data.

VSCode Integration

Configure VSCode to use LookC MCP server through HTTP transport for company research capabilities.

HTTP Client Configuration

VSCode HTTP setup

{
  "rest-client.environmentVariables": {
    "local": {
      "lookc_endpoint": "https://api.lookc.io/mcp",
      "lookc_api_key": "${env:LOOKC_API_KEY}"
    }
  },
  "lookc.mcp.endpoint": "https://api.lookc.io/mcp",
  "lookc.mcp.timeout": 30000
}

Custom Extension Development

VSCode extension

import * as vscode from 'vscode';
import axios from 'axios';

interface LookCMCPClient {
  callTool(toolName: string, arguments: any): Promise<any>;
}

class LookCMCPClientImpl implements LookCMCPClient {
  private apiKey: string;
  private endpoint = 'https://api.lookc.io/mcp';

  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }

  async callTool(toolName: string, arguments: any): Promise<any> {
    const payload = {
      jsonrpc: '2.0',
      id: Date.now(),
      method: 'tools/call',
      params: {
        name: toolName,
        arguments
      }
    };

    const response = await axios.post(this.endpoint, payload, {
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${this.apiKey}`
      }
    });

    return response.data;
  }
}

export function activate(context: vscode.ExtensionContext) {
  const apiKey = vscode.workspace.getConfiguration().get<string>('lookc.apiKey');
  
  if (!apiKey) {
    vscode.window.showErrorMessage('LookC API key not configured');
    return;
  }

  const client = new LookCMCPClientImpl(apiKey);

  const researchCommand = vscode.commands.registerCommand(
    'lookc.researchCompany',
    async () => {
      const linkedinUrl = await vscode.window.showInputBox({
        prompt: 'Enter LinkedIn company URL',
        placeholder: 'https://www.linkedin.com/company/example'
      });

      if (!linkedinUrl) return;

      try {
        const result = await client.callTool('get_organization_ids', {
          linkedin_url: linkedinUrl
        });

        const panel = vscode.window.createWebviewPanel(
          'lookc-research',
          'LookC Company Research',
          vscode.ViewColumn.One,
          { enableScripts: true }
        );

        panel.webview.html = generateResearchHTML(result);
      } catch (error) {
        vscode.window.showErrorMessage(`Research failed: ${error}`);
      }
    }
  );

  context.subscriptions.push(researchCommand);
}

function generateResearchHTML(data: any): string {
  return `
    <!DOCTYPE html>
    <html>
    <head>
      <title>Company Research</title>
      <style>
        body { font-family: Arial, sans-serif; padding: 20px; }
        .company-info { background: #f5f5f5; padding: 15px; border-radius: 5px; }
      </style>
    </head>
    <body>
      <h1>Company Research Results</h1>
      <div class="company-info">
        <pre>${JSON.stringify(data, null, 2)}</pre>
      </div>
    </body>
    </html>
  `;
}

Cursor Integration

Cursor's AI-powered development environment can leverage LookC MCP server through HTTP transport.

HTTP Configuration

Cursor HTTP setup

{
  "cursor.ai.contextSources": ["lookc-http"],
  "cursor.ai.enableHTTPTools": true,
  "lookc.http.endpoint": "https://api.lookc.io/mcp",
  "lookc.http.headers": {
    "Authorization": "Bearer ${env:LOOKC_API_KEY}",
    "Content-Type": "application/json"
  }
}

Development Workflows

Common development workflows enhanced with LookC integration.

Customer Research Workflow

Customer research

interface CustomerResearchWorkflow {
  prospectCompany(linkedinUrl: string): Promise<CompanyProfile>;
  identifyDecisionMakers(orgId: string): Promise<Employee[]>;
  analyzeTeamStructure(employees: Employee[]): TeamAnalysis;
}

class LookCCustomerResearch implements CustomerResearchWorkflow {
  private endpoint = 'https://api.lookc.io/mcp';
  private apiKey: string;

  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }

  async prospectCompany(linkedinUrl: string): Promise<CompanyProfile> {
    // Get organization information
    const orgInfo = await this.callTool('get_organization_ids', {
      linkedin_url: linkedinUrl
    });

    // Get employee overview
    const employees = await this.callTool('get_employee_list', {
      org_id: orgInfo.orgId,
      limit: 200
    });

    return {
      organization: orgInfo,
      employeeCount: employees.employees.length,
      departments: this.categorizeDepartments(employees.employees),
      keyPersonnel: employees.employees.filter(emp => 
        emp.seniority_level === 'PARTNER_CXO'
      )
    };
  }

  async identifyDecisionMakers(orgId: string): Promise<Employee[]> {
    const result = await this.callTool('get_employee_list', {
      org_id: orgId,
      title_regex: 'cto|vp|director|head of|chief',
      seniority_levels: ['PARTNER_CXO', 'VP_DIRECTOR'],
      limit: 50
    });

    return result.employees;
  }

  private async callTool(toolName: string, arguments: any) {
    const response = await fetch(this.endpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${this.apiKey}`
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: Date.now(),
        method: 'tools/call',
        params: { name: toolName, arguments }
      })
    });

    const result = await response.json();
    return result.result.content[0].text ? JSON.parse(result.result.content[0].text) : result.result;
  }
}

Best Practices

Environment Security

Store API keys in environment variables and never commit them to version control.

HTTP Transport

Use standard HTTP clients for maximum compatibility across development tools.

For additional integration patterns, explore our Custom Agents guide and LLM Frameworks documentation.