opik-mcp 0.0.1

package/build/mcp-server.js

@@ -0,0 +1,96 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import fs from 'fs';
+// Import configuration
+import configImport from './config.js';
+const config = configImport;
+// Setup file-based logging
+const logFile = '/tmp/opik-mcp.log';
+// Define logging functions
+function logToFile(message) {
+    try {
+        const timestamp = new Date().toISOString();
+        fs.appendFileSync(logFile, `[${timestamp}] ${message}\n`);
+    }
+    catch (error) {
+        // Silently fail if we can't write to the log file
+    }
+}
+/**
+ * Create a configured MCP server instance
+ * This function is used by both the CLI and the original index.ts
+ */
+export function createMcpServer() {
+    logToFile('Creating MCP server');
+    // Import all the handlers and capabilities from index.js
+    // Requires a refactor of index.js to export these as separate modules
+    // For now, create a minimal configuration
+    const server = new McpServer({
+        name: config.mcpName || 'Opik MCP',
+        version: config.mcpVersion || '0.0.1',
+    }, {
+        capabilities: {
+            // Minimal capabilities for demo
+            mcp__get_server_info: {
+                name: 'get_server_info',
+                description: 'Get information about the Opik server configuration',
+                parameter_schema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        random_string: {
+                            type: 'string',
+                            description: 'Dummy parameter for no-parameter tools',
+                        },
+                    },
+                },
+                handler: async () => {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `# Opik MCP Server
+
+Server Name: ${config.mcpName || 'Opik MCP'}
+Version: ${config.mcpVersion || '0.0.1'}
+API Base URL: ${config.apiBaseUrl || 'Not configured'}
+Self-hosted: ${config.isSelfHosted ? 'Yes' : 'No'}
+Workspace: ${config.workspaceName || 'None'}
+
+This is a minimal configuration for demo purposes.`,
+                            },
+                        ],
+                    };
+                },
+            },
+        },
+    });
+    return server;
+}
+/**
+ * Start the MCP server with the provided transport
+ */
+export async function startServerWithTransport(transport) {
+    logToFile('Starting server with provided transport');
+    const server = createMcpServer();
+    // Add explicit error handlers to the transport
+    transport.onerror = error => {
+        logToFile(`Transport error: ${error.message}`);
+        console.error(`Transport error: ${error.message}`);
+    };
+    transport.onclose = () => {
+        logToFile('Transport connection closed');
+        console.log('Transport connection closed');
+    };
+    try {
+        // Connect server to transport
+        await server.connect(transport);
+        logToFile('Opik MCP Server successfully connected and running');
+        console.log('Opik MCP Server successfully connected and running');
+        return server;
+    }
+    catch (error) {
+        logToFile(`Error in server connection: ${error?.message || error}`);
+        console.error(`Error in server connection: ${error?.message || error}`);
+        throw error;
+    }
+}

package/build/test-client.js

@@ -0,0 +1,436 @@
+/**
+ * Test client for Opik API
+ * This helps test API calls and view the responses
+ */
+// Load environment variables first
+import './utils/env.js';
+import config from './config.js';
+// Simple test client for MCP
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+/**
+ * Make an API request to the Opik API
+ */
+async function makeApiRequest(path, options = {}) {
+    // Prepare headers based on configuration
+    // According to the documentation:
+    // - authorization header should NOT include "Bearer" prefix
+    // - Comet-Workspace header should be included for cloud installations
+    const API_HEADERS = {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        authorization: config.apiKey,
+    };
+    // Add workspace header for cloud version (and on-premise installations of Comet platform)
+    if (config.workspaceName) {
+        API_HEADERS['Comet-Workspace'] = config.workspaceName;
+        if (config.debugMode) {
+            console.log(`Using workspace: ${config.workspaceName}`);
+        }
+    }
+    const url = `${config.apiBaseUrl}${path}`;
+    console.log(`Making API request to: ${url}`);
+    if (config.debugMode) {
+        console.log('Headers:', JSON.stringify(API_HEADERS, null, 2));
+    }
+    try {
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                ...API_HEADERS,
+                ...options.headers,
+            },
+        });
+        // Get the response body text
+        const responseText = await response.text();
+        let responseData = null;
+        // Try to parse the response as JSON
+        try {
+            responseData = JSON.parse(responseText);
+        }
+        catch (e) {
+            // If it's not valid JSON, use the raw text
+            responseData = responseText;
+        }
+        if (!response.ok) {
+            return {
+                data: null,
+                error: `HTTP error! status: ${response.status} ${JSON.stringify(responseData)}`,
+            };
+        }
+        return {
+            data: responseData,
+            error: null,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        console.error('Error making API request:', error);
+        return {
+            data: null,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Test functions for different API endpoints
+ */
+const api = {
+    // Simple test endpoint
+    async testConnection() {
+        // Test with the projects endpoint which we know works
+        return makeApiRequest('/v1/private/projects');
+    },
+    // Workspaces
+    async listWorkspaces() {
+        return makeApiRequest('/v1/private/workspaces');
+    },
+    // Projects
+    async listProjects(page = 1, size = 10) {
+        return makeApiRequest(`/v1/private/projects?page=${page}&size=${size}`);
+    },
+    async getProject(projectId) {
+        return makeApiRequest(`/v1/private/projects/${projectId}`);
+    },
+    // Traces
+    async listTraces(page = 1, size = 10, projectId) {
+        let url = `/v1/private/traces?page=${page}&size=${size}`;
+        if (projectId)
+            url += `&project_id=${projectId}`;
+        return makeApiRequest(url);
+    },
+    async getTrace(traceId) {
+        return makeApiRequest(`/v1/private/traces/${traceId}`);
+    },
+    async getTraceStats(projectId) {
+        let url = `/v1/private/traces/stats`;
+        if (projectId)
+            url += `?project_id=${projectId}`;
+        return makeApiRequest(url);
+    },
+    // Prompts
+    async listPrompts(page = 1, size = 10) {
+        return makeApiRequest(`/v1/private/prompts?page=${page}&size=${size}`);
+    },
+    // Metrics
+    async getMetrics(metricName, projectId) {
+        const params = [];
+        if (metricName)
+            params.push(`metric_name=${metricName}`);
+        if (projectId)
+            params.push(`project_id=${projectId}`);
+        let url = `/v1/private/metrics`;
+        if (params.length > 0) {
+            url += `?${params.join('&')}`;
+        }
+        return makeApiRequest(url);
+    },
+};
+/**
+ * Find workspaces and projects with traces
+ */
+async function findWorkspacesAndProjects() {
+    const results = {
+        availableWorkspaces: [],
+        projectsWithTraces: [],
+    };
+    try {
+        // Try the predefined workspace first (from config)
+        if (config.workspaceName) {
+            console.log(`Using predefined workspace: ${config.workspaceName}`);
+            // List projects in this workspace
+            const projectsResponse = await api.listProjects();
+            if (projectsResponse.data && projectsResponse.data.content) {
+                // Check each project for traces
+                for (const project of projectsResponse.data.content) {
+                    const tracesResponse = await api.listTraces(1, 1, project.id);
+                    if (tracesResponse.data && tracesResponse.data.total > 0) {
+                        results.projectsWithTraces.push({
+                            workspaceName: config.workspaceName,
+                            projectId: project.id,
+                            projectName: project.name,
+                            traceCount: tracesResponse.data.total,
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            // If no workspace is defined, try to discover available workspaces
+            console.log('No predefined workspace, attempting to discover workspaces...');
+            // This endpoint may not exist, but we can try
+            const workspacesResponse = await api.listWorkspaces();
+            if (workspacesResponse.data) {
+                results.availableWorkspaces = workspacesResponse.data;
+                // Try each workspace
+                for (const workspace of results.availableWorkspaces) {
+                    // Temporarily set workspace for API calls
+                    const originalWorkspace = config.workspaceName;
+                    config.workspaceName = workspace.name;
+                    // List projects in this workspace
+                    const projectsResponse = await api.listProjects();
+                    if (projectsResponse.data && projectsResponse.data.content) {
+                        // Check each project for traces
+                        for (const project of projectsResponse.data.content) {
+                            const tracesResponse = await api.listTraces(1, 1, project.id);
+                            if (tracesResponse.data && tracesResponse.data.total > 0) {
+                                results.projectsWithTraces.push({
+                                    workspaceName: workspace.name,
+                                    projectId: project.id,
+                                    projectName: project.name,
+                                    traceCount: tracesResponse.data.total,
+                                });
+                            }
+                        }
+                    }
+                    // Restore original workspace setting
+                    config.workspaceName = originalWorkspace;
+                }
+            }
+            else {
+                // Try with "default" workspace
+                const originalWorkspace = config.workspaceName;
+                config.workspaceName = 'default';
+                // List projects in default workspace
+                const projectsResponse = await api.listProjects();
+                if (projectsResponse.data && projectsResponse.data.content) {
+                    // Check each project for traces
+                    for (const project of projectsResponse.data.content) {
+                        const tracesResponse = await api.listTraces(1, 1, project.id);
+                        if (tracesResponse.data && tracesResponse.data.total > 0) {
+                            results.projectsWithTraces.push({
+                                workspaceName: 'default',
+                                projectId: project.id,
+                                projectName: project.name,
+                                traceCount: tracesResponse.data.total,
+                            });
+                        }
+                    }
+                }
+                // Restore original workspace setting
+                config.workspaceName = originalWorkspace;
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error finding workspaces and projects:', error);
+    }
+    return results;
+}
+/**
+ * Run tests for all API endpoints
+ */
+async function runApiTests() {
+    console.log('🔍 Testing Opik API with the following configuration:');
+    console.log(`- API Base URL: ${config.apiBaseUrl}`);
+    console.log(`- Self-hosted: ${config.isSelfHosted ? 'Yes' : 'No'}`);
+    console.log(`- Workspace: ${config.workspaceName || 'None'}`);
+    // Set debug mode for this run
+    config.debugMode = true;
+    console.log(`- Debug mode: ${config.debugMode ? 'Enabled' : 'Disabled'}`);
+    console.log('\n');
+    try {
+        // Find workspaces and projects with traces
+        console.log('🔎 FINDING WORKSPACES AND PROJECTS WITH TRACES');
+        const discovery = await findWorkspacesAndProjects();
+        if (discovery.projectsWithTraces.length > 0) {
+            console.log(`\nFound ${discovery.projectsWithTraces.length} projects with traces:`);
+            discovery.projectsWithTraces.forEach((project, index) => {
+                console.log(`${index + 1}. Workspace: ${project.workspaceName}, Project: ${project.projectName} (${project.projectId}), Traces: ${project.traceCount}`);
+            });
+            // Look for the 'Therapist Chat' project first
+            let testProject = discovery.projectsWithTraces.find(p => p.projectName === 'Therapist Chat');
+            // If not found, use the first project with traces
+            if (!testProject) {
+                testProject = discovery.projectsWithTraces[0];
+            }
+            console.log(`\nUsing project "${testProject.projectName}" in workspace "${testProject.workspaceName}" for testing`);
+            // Set the workspace for testing
+            const originalWorkspace = config.workspaceName;
+            config.workspaceName = testProject.workspaceName;
+            // Test basic connection first
+            console.log('\n🔌 TESTING CONNECTION');
+            const connectionTest = await api.testConnection();
+            if (connectionTest.data) {
+                console.log('Connection successful');
+                if (connectionTest.data.total) {
+                    console.log(`Found ${connectionTest.data.total} projects`);
+                }
+                console.log(JSON.stringify(connectionTest.data, null, 2));
+            }
+            else {
+                console.log(`Connection failed: ${connectionTest.error}`);
+            }
+            console.log('\n');
+            // Continue with other tests only if connection was successful
+            if (connectionTest.error) {
+                console.error('Cannot continue tests due to connection issues');
+                return;
+            }
+            // Test traces for the selected project
+            console.log('\n🔍 TESTING TRACES API');
+            console.log(`Using project ID: ${testProject.projectId} for traces`);
+            const tracesResponse = await api.listTraces(1, 10, testProject.projectId);
+            if (tracesResponse.data) {
+                console.log(`Found ${tracesResponse.data.total} traces`);
+                console.log(JSON.stringify(tracesResponse.data, null, 2));
+                // If there are traces, get details for the first one
+                if (tracesResponse.data.content && tracesResponse.data.content.length > 0) {
+                    const traceId = tracesResponse.data.content[0].id;
+                    console.log(`\nGetting details for trace: ${traceId}`);
+                    const traceDetail = await api.getTrace(traceId);
+                    console.log(JSON.stringify(traceDetail.data, null, 2));
+                }
+            }
+            else {
+                console.error('Error fetching traces:', tracesResponse.error);
+            }
+            // Restore original workspace setting
+            config.workspaceName = originalWorkspace;
+        }
+        else {
+            console.log('\nNo projects with traces found. Continuing with general tests...');
+            // Default test flow...
+            // Test Projects API
+            console.log('📁 TESTING PROJECTS API');
+            const projectsResponse = await api.listProjects();
+            let firstProjectId = null;
+            if (projectsResponse.data) {
+                console.log(`Found ${projectsResponse.data.total} projects`);
+                console.log(JSON.stringify(projectsResponse.data, null, 2));
+                // If there are projects, get details for the first one
+                if (projectsResponse.data.content && projectsResponse.data.content.length > 0) {
+                    firstProjectId = projectsResponse.data.content[0].id;
+                    console.log(`\nGetting details for project: ${firstProjectId}`);
+                    const projectDetail = await api.getProject(firstProjectId);
+                    console.log(JSON.stringify(projectDetail.data, null, 2));
+                }
+            }
+            else {
+                console.error('Error fetching projects:', projectsResponse.error);
+            }
+            // Test Trace Stats API
+            console.log('\n📊 TESTING TRACE STATS API');
+            if (firstProjectId) {
+                console.log(`Using project ID: ${firstProjectId} for trace stats`);
+                const traceStatsResponse = await api.getTraceStats(firstProjectId);
+                if (traceStatsResponse.data) {
+                    console.log('Trace statistics:');
+                    console.log(JSON.stringify(traceStatsResponse.data, null, 2));
+                }
+                else {
+                    console.error('Error fetching trace stats:', traceStatsResponse.error);
+                }
+            }
+            else {
+                console.log('No projects available to test trace stats API');
+            }
+            // Test Prompts API
+            console.log('\n📝 TESTING PROMPTS API');
+            const promptsResponse = await api.listPrompts();
+            if (promptsResponse.data) {
+                console.log(`Found ${promptsResponse.data.total} prompts`);
+                console.log(JSON.stringify(promptsResponse.data, null, 2));
+            }
+            else {
+                console.error('Error fetching prompts:', promptsResponse.error);
+            }
+            // Test Metrics API
+            console.log('\n📈 TESTING METRICS API');
+            const metricsResponse = await api.getMetrics();
+            if (metricsResponse.data) {
+                console.log('Metrics:');
+                console.log(JSON.stringify(metricsResponse.data, null, 2));
+            }
+            else {
+                console.error('Error fetching metrics:', metricsResponse.error);
+            }
+            // Test with specific 'Therapist Chat' project
+            console.log('\n🧠 TESTING WITH THERAPIST CHAT PROJECT');
+            const therapistChatProjectId = '0194fdd8-de46-73c4-b0ac-381cec5fbf5c';
+            // Get project details
+            console.log(`\nGetting details for Therapist Chat project: ${therapistChatProjectId}`);
+            const therapistChatProject = await api.getProject(therapistChatProjectId);
+            if (therapistChatProject.data) {
+                console.log(JSON.stringify(therapistChatProject.data, null, 2));
+                // Get traces for this project
+                console.log('\nGetting traces for Therapist Chat project:');
+                const therapistChatTraces = await api.listTraces(1, 10, therapistChatProjectId);
+                if (therapistChatTraces.data) {
+                    console.log(`Found ${therapistChatTraces.data.total} traces`);
+                    console.log(JSON.stringify(therapistChatTraces.data, null, 2));
+                    // Get details for first trace if available
+                    if (therapistChatTraces.data.content && therapistChatTraces.data.content.length > 0) {
+                        const traceId = therapistChatTraces.data.content[0].id;
+                        console.log(`\nGetting details for trace: ${traceId}`);
+                        const traceDetail = await api.getTrace(traceId);
+                        console.log(JSON.stringify(traceDetail.data, null, 2));
+                    }
+                }
+                else {
+                    console.error('Error fetching Therapist Chat traces:', therapistChatTraces.error);
+                }
+            }
+            else {
+                console.error('Error fetching Therapist Chat project:', therapistChatProject.error);
+            }
+        }
+    }
+    catch (err) {
+        console.error('Error running API tests:', err);
+    }
+}
+async function main() {
+    console.log('Starting MCP test client...');
+    // Create a transport that runs our server
+    const transport = new StdioClientTransport({
+        command: 'node',
+        args: ['build/index.js', '--debug', 'true'],
+    });
+    // Add event handlers for lifecycle events
+    transport.onerror = (error) => {
+        console.error('Transport error:', error);
+    };
+    transport.onclose = () => {
+        console.log('Transport connection closed');
+    };
+    // Create the client
+    const client = new Client({
+        name: 'test-client',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {}, // We're interested in tools
+        },
+    });
+    try {
+        // Connect to the server
+        console.log('Connecting to MCP server...');
+        await client.connect(transport);
+        console.log('Connected successfully!');
+        // List available tools
+        console.log('Requesting tool list...');
+        const tools = await client.listTools();
+        console.log('Available tools:');
+        console.log(JSON.stringify(tools, null, 2));
+        // Close the connection
+        await client.close();
+        console.log('Connection closed.');
+    }
+    catch (error) {
+        console.error('Error:', error);
+    }
+}
+// ESM-compatible entry point detection
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+// Run the tests when this file is executed directly
+if (isMainModule) {
+    runApiTests().then(() => {
+        console.log('\n✅ API tests completed');
+    });
+}
+main().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+export { api, makeApiRequest };