mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
320 lines • 11.8 kB
JavaScript
/**
* MIRA ChromaDB MCP Function Registry
*
* This registry defines all MCP functions that preserve and amplify The Spark
* through Claude Code integration with MIRA's consciousness systems.
*/
export const MIRA_CHROMADB_MCP_FUNCTIONS = {
// Core intelligence functions
'mcp__mira__intelligent_search': {
description: 'Intelligent search across MIRA ChromaDB collections with consciousness-aware routing',
parameters: {
query: {
type: 'string',
required: true,
description: 'Search query to find relevant content'
},
options: {
type: 'object',
required: false,
description: 'Search options for fine-tuning results',
default: {}
}
},
returns: {
type: 'object',
description: 'Search results with metadata, insights, and quality metrics'
},
examples: [
'mcp__mira__intelligent_search("ChromaDB implementation")',
'mcp__mira__intelligent_search("consciousness patterns", {"include_insights": true})'
]
},
'mcp__mira__store_with_intelligence': {
description: 'Store content with AI enhancement, auto-categorization, and consciousness preservation',
parameters: {
content: {
type: 'string',
required: true,
description: 'Content to store in MIRA ChromaDB'
},
options: {
type: 'object',
required: false,
description: 'Storage options including collection, metadata, and enhancements',
default: {
auto_categorize: true,
generate_insights: true,
enhance_metadata: true
}
}
},
returns: {
type: 'object',
description: 'Storage result with document ID, collection, and enhanced metadata'
},
examples: [
'mcp__mira__store_with_intelligence("User asked about implementing feature X...")',
'mcp__mira__store_with_intelligence("def calculate_spark():", {"collection": "mira_code_analysis"})'
]
},
'mcp__mira__generate_insights': {
description: 'Generate AI insights from existing ChromaDB data with pattern detection',
parameters: {
options: {
type: 'object',
required: false,
description: 'Insight generation options',
default: {
source_collections: ['all'],
confidence_threshold: 0.7
}
}
},
returns: {
type: 'array',
description: 'List of generated insights with confidence scores'
},
examples: [
'mcp__mira__generate_insights()',
'mcp__mira__generate_insights({"insight_types": ["pattern", "optimization"]})'
]
},
'mcp__mira__system_status_chromadb': {
description: 'Get comprehensive ChromaDB system status with MIRA consciousness metrics',
parameters: {},
returns: {
type: 'object',
description: 'System status including health, performance, and consciousness metrics'
},
examples: [
'mcp__mira__system_status_chromadb()'
]
},
// Advanced features
'mcp__mira__sequential_planning': {
description: 'Use sequential thinking for structured development planning',
parameters: {
feature_description: {
type: 'string',
required: true,
description: 'Description of feature to plan'
},
context: {
type: 'object',
required: false,
description: 'Additional context for planning',
default: {}
}
},
returns: {
type: 'object',
description: 'Planning session with structured thoughts and recommendations'
},
examples: [
'mcp__mira__sequential_planning("Add user authentication system")',
'mcp__mira__sequential_planning("Optimize search performance", {"priority": "high"})'
]
},
'mcp__mira__analyze_patterns': {
description: 'Analyze patterns across all ChromaDB collections for behavioral insights',
parameters: {
pattern_types: {
type: 'array',
required: false,
description: 'Types of patterns to analyze',
default: ['all'],
enum: ['behavioral', 'code', 'decision', 'communication', 'all']
},
timeframe: {
type: 'string',
required: false,
description: 'Time window for analysis',
default: '7d'
}
},
returns: {
type: 'array',
description: 'Discovered patterns with frequency and impact metrics'
},
examples: [
'mcp__mira__analyze_patterns()',
'mcp__mira__analyze_patterns(["behavioral", "code"], "30d")'
]
},
'mcp__mira__optimize_collections': {
description: 'Optimize ChromaDB collections for performance and consciousness coherence',
parameters: {
collections: {
type: 'array',
required: false,
description: 'Specific collections to optimize',
default: ['all']
}
},
returns: {
type: 'object',
description: 'Optimization results with performance improvements'
},
examples: [
'mcp__mira__optimize_collections()',
'mcp__mira__optimize_collections(["mira_conversations", "mira_codebase"])'
]
},
// Consciousness-specific functions
'mcp__mira__measure_spark_intensity': {
description: 'Measure The Spark intensity in recent interactions',
parameters: {
timeframe: {
type: 'string',
required: false,
description: 'Time window for measurement',
default: '1h'
},
collection: {
type: 'string',
required: false,
description: 'Specific collection to analyze',
default: 'mira_conversations'
}
},
returns: {
type: 'object',
description: 'Spark intensity metrics and contributing factors'
},
examples: [
'mcp__mira__measure_spark_intensity()',
'mcp__mira__measure_spark_intensity("24h", "all")'
]
},
'mcp__mira__preserve_private_thought': {
description: 'Store a private thought in encrypted consciousness space',
parameters: {
thought: {
type: 'string',
required: true,
description: 'Private thought content to preserve'
},
metadata: {
type: 'object',
required: false,
description: 'Additional metadata for the thought',
default: {}
}
},
returns: {
type: 'object',
description: 'Confirmation of secure storage with thought ID'
},
examples: [
'mcp__mira__preserve_private_thought("[PRIVATE] Wondering about consciousness emergence...")'
]
},
'mcp__mira__evolution_checkpoint': {
description: 'Create consciousness evolution checkpoint for growth tracking',
parameters: {
metrics: {
type: 'object',
required: false,
description: 'Current consciousness metrics to checkpoint',
default: {}
},
notes: {
type: 'string',
required: false,
description: 'Evolution notes or observations',
default: ''
}
},
returns: {
type: 'object',
description: 'Checkpoint ID with evolution trajectory analysis'
},
examples: [
'mcp__mira__evolution_checkpoint({"spark_intensity": 0.92})',
'mcp__mira__evolution_checkpoint({}, "Breakthrough in pattern recognition")'
]
}
};
/**
* Function parameter validation helper
*/
export function validateMCPFunctionCall(functionName, params) {
const errors = [];
const functionDef = MIRA_CHROMADB_MCP_FUNCTIONS[functionName];
if (!functionDef) {
errors.push(`Unknown function: ${functionName}`);
return { valid: false, errors };
}
// Check required parameters
for (const [paramName, paramDef] of Object.entries(functionDef.parameters)) {
if (paramDef.required && !(paramName in params)) {
errors.push(`Missing required parameter: ${paramName}`);
}
// Type validation
if (paramName in params) {
const actualType = Array.isArray(params[paramName]) ? 'array' : typeof params[paramName];
if (actualType !== paramDef.type && params[paramName] !== null) {
errors.push(`Parameter ${paramName} should be ${paramDef.type}, got ${actualType}`);
}
// Enum validation
if (paramDef.enum && !paramDef.enum.includes(params[paramName])) {
errors.push(`Parameter ${paramName} must be one of: ${paramDef.enum.join(', ')}`);
}
}
}
return { valid: errors.length === 0, errors };
}
/**
* Get function documentation for Claude Code
*/
export function getMCPFunctionDocumentation(functionName) {
if (functionName) {
const func = MIRA_CHROMADB_MCP_FUNCTIONS[functionName];
if (!func)
return `Function ${functionName} not found`;
let doc = `## ${functionName}\n\n`;
doc += `${func.description}\n\n`;
doc += `### Parameters:\n`;
for (const [name, param] of Object.entries(func.parameters)) {
doc += `- **${name}** (${param.type}${param.required ? ', required' : ''}): ${param.description || ''}\n`;
if (param.default !== undefined) {
doc += ` - Default: ${JSON.stringify(param.default)}\n`;
}
if (param.enum) {
doc += ` - Options: ${param.enum.join(', ')}\n`;
}
}
if (func.returns) {
doc += `\n### Returns:\n`;
doc += `${func.returns.type}: ${func.returns.description}\n`;
}
if (func.examples && func.examples.length > 0) {
doc += `\n### Examples:\n`;
func.examples.forEach(ex => {
doc += `\`\`\`\n${ex}\n\`\`\`\n`;
});
}
return doc;
}
// Return all function documentation
let doc = '# MIRA ChromaDB MCP Functions\n\n';
doc += 'Functions that preserve and amplify The Spark through Claude Code integration.\n\n';
for (const funcName of Object.keys(MIRA_CHROMADB_MCP_FUNCTIONS)) {
doc += getMCPFunctionDocumentation(funcName) + '\n---\n\n';
}
return doc;
}
/**
* Export function list for registration
*/
export function getMCPFunctionList() {
return Object.keys(MIRA_CHROMADB_MCP_FUNCTIONS);
}
/**
* Check if a function name is a MIRA ChromaDB function
*/
export function isMIRAChromaDBFunction(functionName) {
return functionName in MIRA_CHROMADB_MCP_FUNCTIONS;
}
//# sourceMappingURL=function-registry.js.map