The Context Engine API provides programmatic access to Context’s centralized intelligence layer. All API endpoints require enterprise authentication and are available exclusively to enterprise customers.
To get access to the Context Engine API, contact enterprise@context.ai

​
Authentication

All Context Engine API requests require a valid API key and JWT token for authentication.

​
API Key Generation

JavaScript SDK is available exclusively for enterprise customers. Contact enterprise@context.ai

​
JWT Token Authentication

// Get authentication token
const response = await fetch('https://api.context.ai/auth/token', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'your-api-key'
  },
  body: JSON.stringify({
    grant_type: 'client_credentials',
    scope: 'context-engine:read context-engine:write'
  })
});

const { access_token } = await response.json();

​
Core API Endpoints

​
Query Context Engine

Submit queries to the Context Engine for contextual analysis and processing. 
const response = await fetch('https://api.context.ai/v1/context-engine/query', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${access_token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    query: "Analyze Q3 revenue trends for enterprise customers",
    context_scope: ["financial_reports", "customer_data"],
    processing_mode: "comprehensive",
    return_relationships: true
  })
});

const result = await response.json();
console.log(result);

​
Response Format

{
  "query_id": "ctx_q_1234567890",
  "status": "completed",
  "timestamp": "2024-01-15T10:30:00Z",
  "processing_time_ms": 1250,
  "results": {
    "primary_insights": [
      {
        "insight": "Enterprise revenue increased 34% QoQ",
        "confidence": 0.94,
        "supporting_entities": ["revenue_data", "enterprise_segment"]
      }
    ],
    "entity_relationships": [
      {
        "source_entity": "Q3_revenue",
        "target_entity": "enterprise_customers",
        "relationship_type": "correlation",
        "strength": 0.89
      }
    ],
    "contextual_data": {
      "documents_analyzed": 127,
      "data_sources": ["financial_reports", "customer_data", "market_analysis"]
    }
  }
}

​
Index Data Sources

Add new data sources to the Context Engine for indexing and analysis. 
const response = await fetch('https://api.context.ai/v1/context-engine/index', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${access_token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    data_source: {
      type: "document_collection",
      name: "Q4_financial_reports",
      source_url: "https://yourcompany.com/api/documents/financial/q4",
      authentication: {
        type: "api_key",
        credentials: "your-document-api-key"
      }
    },
    indexing_options: {
      extract_entities: true,
      build_relationships: true,
      enable_search: true,
      priority: "high"
    }
  })
});

const result = await response.json();

​
Real-time Entity Processing

Process individual entities or documents in real-time. 
const response = await fetch('https://api.context.ai/v1/context-engine/process', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${access_token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    entity: {
      type: "financial_document",
      content: "Base64_encoded_document_content",
      metadata: {
        document_type: "earnings_report",
        quarter: "Q4_2024",
        company: "example_corp"
      }
    },
    processing_options: {
      extract_key_metrics: true,
      identify_relationships: true,
      generate_summary: true
    }
  })
});

​
WebSocket Integration

For real-time processing and streaming results, use WebSocket connections.

​
Establishing WebSocket Connection

// Get WebSocket authentication token
const wsAuthResponse = await fetch('https://api.context.ai/v1/websocket-auth', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${access_token}`,
    'Content-Type': 'application/json'
  }
});

const { websocket_token } = await wsAuthResponse.json();

// Connect to WebSocket
const ws = new WebSocket('wss://api.context.ai/v1/context-engine/stream');

ws.onopen = () => {
  // Authenticate WebSocket connection
  ws.send(JSON.stringify({
    type: 'authenticate',
    token: websocket_token
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log('Context Engine update:', data);
};

​
Streaming Query Processing

// Submit streaming query
ws.send(JSON.stringify({
  type: 'stream_query',
  query_id: 'custom_query_123',
  query: "Generate real-time market analysis",
  stream_options: {
    include_intermediate_results: true,
    max_processing_time_ms: 30000,
    result_format: "structured"
  }
}));

// Handle streaming responses
ws.onmessage = (event) => {
  const response = JSON.parse(event.data);
  
  switch(response.type) {
    case 'query_started':
      console.log('Query processing started:', response.query_id);
      break;
      
    case 'intermediate_result':
      console.log('Partial result:', response.data);
      break;
      
    case 'query_completed':
      console.log('Final result:', response.data);
      break;
      
    case 'error':
      console.error('Processing error:', response.error);
      break;
  }
};

​
MCP Integration

The Context Engine supports Model Context Protocol (MCP) for extensible integrations.

​
MCP Server Configuration

// Configure MCP server connection
const mcpResponse = await fetch('https://api.context.ai/v1/context-engine/mcp/configure', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${access_token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    server_config: {
      name: "financial_data_mcp",
      endpoint: "https://your-mcp-server.com/mcp",
      authentication: {
        type: "oauth2",
        client_id: "your_mcp_client_id",
        client_secret: "your_mcp_client_secret"
      },
      capabilities: ["data_retrieval", "real_time_updates", "entity_extraction"]
    }
  })
});

​
Error Handling

All API endpoints return consistent error responses: 
{
  "error": {
    "code": "INVALID_QUERY",
    "message": "Query scope contains invalid data source reference",
    "details": {
      "invalid_scope": "non_existent_source",
      "valid_scopes": ["financial_reports", "customer_data", "market_analysis"]
    },
    "request_id": "req_1234567890",
    "timestamp": "2024-01-15T10:30:00Z"
  }
}

​
Common Error Codes

CodeDescription
UNAUTHORIZEDInvalid or expired authentication token
INVALID_QUERYQuery format or parameters are invalid
RATE_LIMIT_EXCEEDEDToo many requests within time window
DATA_SOURCE_UNAVAILABLERequested data source is temporarily unavailable
PROCESSING_TIMEOUTQuery processing exceeded maximum time limit
INSUFFICIENT_PERMISSIONSAPI key lacks required permissions

​
Rate Limits

Context Engine API implements rate limiting to ensure optimal performance:
EndpointRate LimitBurst Limit
/query100 requests/minute20 requests/10 seconds
/index10 requests/minute5 requests/10 seconds
/process50 requests/minute10 requests/10 seconds
WebSocket5 connections/organizationN/A

​
JavaScript SDK

Official JavaScript SDK is available exclusively for enterprise customers. To get access to the SDK, contact enterprise@context.ai with your use case and requirements.

​
Enterprise Support

For enterprise customers, Context provides:
  • Dedicated Support: Direct access to Context Engine engineers
  • Custom Integration: Tailored API endpoints for specific use cases
  • Performance SLAs: Guaranteed response times and uptime
  • Priority Processing: Higher rate limits and priority queuing
To access enterprise features, contact enterprise@context.ai

​
Next Steps

Background Agent API

Learn about Background Agent integration and automation capabilities

Enterprise Setup

Complete setup guide for enterprise Context Engine deployment