claude-expert-workflow-mcp
Version:
Production-ready MCP server for AI-powered product development consultation through specialized expert roles. Enterprise-grade with memory management, monitoring, and Claude Code integration.
220 lines • 5.95 kB
TypeScript
import Anthropic from '@anthropic-ai/sdk';
/**
* Advanced API integration interfaces
*/
export interface APIBatchRequest {
id: string;
method: 'chat' | 'completion';
params: ChatParams | CompletionParams;
priority: RequestPriority;
timeout?: number;
retryCount?: number;
callback?: (result: APIBatchResult) => void;
}
export interface ChatParams {
messages: Anthropic.MessageParam[];
systemPrompt?: string;
maxTokens?: number;
temperature?: number;
model?: string;
}
export interface CompletionParams {
prompt: string;
maxTokens?: number;
temperature?: number;
model?: string;
}
export interface APIBatchResult {
id: string;
success: boolean;
result?: string;
error?: string;
duration: number;
tokensUsed?: number;
cached?: boolean;
}
export declare enum RequestPriority {
LOW = 1,
NORMAL = 2,
HIGH = 3,
CRITICAL = 4
}
export interface RateLimitConfig {
requestsPerMinute: number;
tokensPerMinute: number;
burstLimit: number;
queueSize: number;
adaptiveThrottling: boolean;
}
export interface APIConnectionConfig {
maxConcurrentRequests: number;
connectionTimeout: number;
requestTimeout: number;
keepAliveTimeout: number;
retryConfig: {
maxRetries: number;
backoffMultiplier: number;
maxBackoffDelay: number;
};
}
export interface TokenUsageMetrics {
totalTokensUsed: number;
requestCount: number;
averageTokensPerRequest: number;
costEstimate: number;
quotaUsagePercentage: number;
}
export interface RequestQueueMetrics {
queueSize: number;
averageWaitTime: number;
processedRequests: number;
failedRequests: number;
throughput: number;
}
/**
* Advanced rate limiter with adaptive throttling
*/
export declare class AdaptiveRateLimiter {
private config;
private requestWindow;
private tokenWindow;
private burstRequests;
private lastResetTime;
private adaptiveMultiplier;
private consecutiveErrors;
constructor(config: RateLimitConfig);
/**
* Check if request can be made based on rate limits
*/
canMakeRequest(estimatedTokens?: number): Promise<boolean>;
/**
* Record a successful request
*/
recordRequest(tokensUsed: number): void;
/**
* Record a failed request (adapts rate limiting)
*/
recordError(error: Error): void;
/**
* Get estimated wait time until next request can be made
*/
getEstimatedWaitTime(): number;
private cleanupOldEntries;
private getAdjustedRequestLimit;
private getAdjustedTokenLimit;
getMetrics(): {
currentRequests: number;
currentTokens: number;
adaptiveMultiplier: number;
consecutiveErrors: number;
estimatedWaitTime: number;
};
}
/**
* Request queue with priority handling and batching
*/
export declare class PriorityRequestQueue {
private queues;
private processing;
private metrics;
private waitTimes;
constructor();
/**
* Add request to queue with priority
*/
enqueue(request: APIBatchRequest): void;
/**
* Get next request based on priority
*/
dequeue(): APIBatchRequest | null;
/**
* Batch multiple requests if possible
*/
dequeueBatch(maxBatchSize?: number): APIBatchRequest[];
/**
* Get queue size for specific priority
*/
getQueueSize(priority?: RequestPriority): number;
/**
* Clear all queues
*/
clear(): void;
/**
* Get queue metrics
*/
getMetrics(): RequestQueueMetrics;
private updateQueueSize;
private recordWaitTime;
recordProcessedRequest(success: boolean): void;
}
/**
* Optimized Claude client with advanced features
*/
export declare class OptimizedClaudeClient {
private rateLimitConfig;
private connectionConfig;
private client;
private rateLimiter;
private requestQueue;
private connectionPool;
private errorRecovery;
private logger;
private tokenUsageMetrics;
private processingInterval?;
private isProcessing;
constructor(rateLimitConfig?: RateLimitConfig, connectionConfig?: APIConnectionConfig);
/**
* Enhanced chat method with batching and optimization
*/
chat(messages: Anthropic.MessageParam[], options?: {
systemPrompt?: string;
priority?: RequestPriority;
timeout?: number;
maxTokens?: number;
temperature?: number;
model?: string;
}): Promise<string>;
/**
* Batch multiple requests for efficient processing
*/
batchRequests(requests: APIBatchRequest[]): Promise<APIBatchResult[]>;
/**
* Optimized expert consultation with caching and rate limiting
*/
consultExpert(expertPrompt: string, userMessage: string, conversationHistory?: Anthropic.MessageParam[], options?: {
priority?: RequestPriority;
expertType?: string;
workflowId?: string;
useCache?: boolean;
}): Promise<string>;
/**
* Get comprehensive API metrics
*/
getMetrics(): {
tokenUsage: TokenUsageMetrics;
queueMetrics: RequestQueueMetrics;
rateLimiterMetrics: any;
connectionPoolStats: any;
};
/**
* Optimize performance based on current metrics
*/
optimizePerformance(): Promise<void>;
/**
* Graceful shutdown
*/
shutdown(): Promise<void>;
private startRequestProcessor;
private processQueuedRequests;
private processRequest;
private executeChat;
private createConnection;
private destroyConnection;
private estimateTokenUsage;
private estimateTokenUsageFromRequest;
private updateTokenUsageMetrics;
private generateRequestId;
private generateCorrelationId;
}
export declare const optimizedClaudeClient: OptimizedClaudeClient;
//# sourceMappingURL=optimizedClient.d.ts.map