> ## Documentation Index > Fetch the complete documentation index at: https://documentation.sophra.org/llms.txt > Use this file to discover all available pages before exploring further. # Log Search Analytics ## OpenAPI ````yaml api/definition.yml post /cortex/analytics/search openapi: 3.0.0 info: title: Sophra description: >- # Overview Sophra is an intelligent search platform built on a dual-service architecture that combines sophisticated document processing with adaptive learning. Through Cortex and Nous, the platform manages both core search operations and continuous learning processes, delivering increasingly relevant search experiences through real-time optimization. Cortex serves as the foundational search engine, handling document operations, session management, and search execution with comprehensive analytics tracking. It maintains system health and performance while providing detailed operational insights through extensive monitoring capabilities. Nous, the intelligence layer, processes learning signals, manages adaptations, and orchestrates systematic testing of both search behavior and business logic. The platform's strength lies in its ability to seamlessly integrate traditional search capabilities with advanced AI-driven optimizations. Through sophisticated signal processing and learning pipelines, Sophra continuously evolves its search behavior based on real-world usage patterns while maintaining strict performance standards and system stability. This creates a self-improving system that delivers increasingly relevant results while providing granular control over its learning and adaptation processes. version: 1.0.0 servers: - url: https://api.sophra.org/api description: Production Server security: [] tags: - name: Administration - name: Cortex description: "Cortex is the foundational search\_engine at the heart of Sophra, handling all core search and document operations with precision and scale. It transforms raw documents into rich, searchable content through advanced processing pipelines that include automatic vectorization, semantic\_analysis, and intelligent indexing.\n\nBeyond basic search capabilities, Cortex manages\_the entire document lifecycle - from initial\_ingestion and processing to storage\_and retrieval. It employs sophisticated caching strategies and real-time optimization to ensure fast, reliable search performance even under\_heavy loads. The service\_automatically handles document versioning, maintains\_consistency across distributed systems, and provides detailed analytics about search performance and\_document usage.\n\nWhat sets Cortex apart\_is its tight integration with\_Nous, Sophra's learning\_layer. Every search operation, document access, and user interaction generates valuable signals that feed into the platform's continuous learning processes. This symbiotic relationship allows Cortex to dynamically adjust its search parameters, relevance calculations, and\_document rankings based on real-world usage patterns and explicit\_feedback.\n\nFor developers, Cortex\_provides a comprehensive API that makes complex\_search operations accessible and manageable. Whether\_you're implementing basic keyword search\_or advanced semantic queries, Cortex's flexible architecture adapts to your needs\_while maintaining consistent performance and reliability.EndFragment" - name: Cortex > System Health description: >- The Health endpoint provides comprehensive system diagnostics across all critical services, offering real-time insights into the platform's operational status. It performs deep health checks across Elasticsearch, PostgreSQL, and Redis services, measuring not just availability but also detailed performance metrics and resource utilization. This endpoint serves as the primary diagnostic tool for system administrators and monitoring services, providing granular visibility into each service's operational state. When called, it conducts parallel health checks with built-in timeout protection, ensuring responsive monitoring even when individual services may be experiencing issues. The health check returns detailed metrics including connection states, performance indicators, and resource usage statistics, all while maintaining a strict service timeout of 15 seconds to prevent cascading failures. ``` typescript export async function GET(_req: NextRequest): Promise { logger.info("Starting health check..."); const startTime = Date.now(); try { const services = await serviceManager.getServices(); const health = { timestamp: new Date().toISOString(), services: { elasticsearch: await checkService("elasticsearch", services.elasticsearch, { cluster: { status: "unknown", nodes: 0, // ... other default metrics } }), postgres: await checkService("postgres", services.postgres, { connections: { active: 0, idle: 0, // ... other default metrics } }), redis: await checkService("redis", services.redis, { memory: { used: "0b", peak: "0b", // ... other default metrics } }) }, overall: false }; // Calculate overall health health.overall = Object.values(health.services).every( (service) => service.operational ); return NextResponse.json({ success: true, data: health, meta: { took: Date.now() - startTime } }); } catch (error) { // Error handling } } ``` The endpoint returns detailed metrics about: - Elasticsearch cluster health and performance - PostgreSQL connection pools and query performance - Redis memory utilization and operation throughput - Overall system operational status - name: Cortex > Session Management description: >- # Session Management The Session Management system in Sophra provides comprehensive tracking and analysis of user interactions throughout their search journey. It maintains stateful sessions with built-in caching, analytics collection, and real-time metric tracking, enabling detailed insights into user behavior and search patterns. The system handles session lifecycle management, from creation through analytics collection to expiration, while maintaining performance through Redis-backed caching. It automatically tracks key metrics including search patterns, click-through rates, and interaction latencies, providing a complete picture of user engagement. Each session maintains its state across multiple searches while collecting analytics data, which can be retrieved through dedicated endpoints for monitoring and optimization purposes. The system includes built-in error handling and logging, ensuring reliable session tracking even under high load. ``` typescript:src/app/api/cortex/sessions/route.ts export async function POST(req: NextRequest): Promise { const startTime = Date.now(); const services = await serviceManager.getServices(); try { const body = await req.json(); const session = await services.sessions.createSession({ userId: body.userId, metadata: body.metadata }); // Cache session for performance await services.sessions.cacheSession( session.id, JSON.stringify(session) ); return NextResponse.json({ success: true, data: { sessionId: session.id, ...session }, cached: true }); } catch (error) { // Error handling with metrics tracking } } ``` **Key Features:** - Real-time session creation and tracking - Redis-backed session caching - Comprehensive analytics collection - Automatic metric tracking - Built-in error handling and logging - Session state persistence - Performance monitoring The system maintains detailed metrics about: - User search patterns and behavior - Session duration and activity - Click-through rates and engagement - Query performance and latency - Error rates and system health - name: Cortex > Index Management description: >- The Index Management endpoints provide comprehensive control over Sophra's search indices, offering capabilities for creation, configuration, and maintenance of the platform's search infrastructure. These endpoints handle everything from basic index operations to advanced configuration management, ensuring optimal search performance and data organization. Through these endpoints, administrators can manage the complete lifecycle of search indices, from initial creation through ongoing maintenance to eventual deletion. The system provides granular control over index settings, including shard allocation, replication strategies, and analysis configurations, while maintaining strict consistency and performance standards. Each operation is protected by built-in validation and error handling, ensuring safe modifications to the index structure even in high-traffic environments. The endpoints track detailed metrics about index operations, providing insights into performance patterns and resource utilization. ``` typescript export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Index creation with validation and configuration const index = await services.indices.createIndex({ name: body.name, settings: body.settings, mappings: body.mappings }); return NextResponse.json({ success: true, data: index, meta: { took: Date.now() - startTime } }); } catch (error) { // Error handling with detailed logging } } ``` **Key Operations:** - Index creation and configuration - Index settings management - Mapping updates and modifications - Index health monitoring - Performance optimization - Deletion and cleanup The endpoints maintain detailed metrics about: - Index health and status - Document counts and storage usage - Shard allocation and replication - Query performance and throughput - Resource utilization and efficiency - name: Cortex > Document Operations description: >- The Document Operations endpoints form the core of Sophra's content management system, handling all aspects of document processing, storage, and retrieval. These endpoints manage the entire document lifecycle, from initial ingestion through vectorization to eventual deletion, while maintaining performance and consistency across all operations. These endpoints incorporate sophisticated processing pipelines that automatically handle document vectorization, metadata extraction, and content analysis. Each document operation is tracked and measured, providing detailed insights into processing performance and system efficiency. The system includes built-in retry mechanisms and failure handling to ensure reliable document processing even under heavy loads. Document operations are designed to maintain consistency across distributed systems while providing real-time access to processed content. The system automatically handles versioning, maintains processing queues, and manages document state transitions throughout their lifecycle. ``` typescript export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Document creation with automatic processing const document = await services.documents.createDocument({ index: body.index, document: { title: body.document.title, content: body.document.content, abstract: body.document.abstract, authors: body.document.authors, tags: body.document.tags, source: body.document.source } }); return NextResponse.json({ success: true, data: { id: document.id, index: document.index, vectorized: document.vectorized, // ... other document metadata } }); } catch (error) { // Comprehensive error handling } } ``` **Key Features:** - Automatic document vectorization - Content analysis and metadata extraction - Version control and state management - Batch processing capabilities - Real-time document updates - Comprehensive error handling The system maintains metrics about: - Document processing times - Vectorization status and quality - Storage utilization - Processing queue health - Error rates and types - System throughput and latency - name: Cortex > Search Operations description: >- The Search Operations endpoints form the heart of Sophra's search functionality, delivering intelligent and contextually aware search results across diverse content types. These endpoints handle everything from basic keyword queries to advanced semantic search operations, while automatically optimizing results based on user behavior and system learning. The system employs a sophisticated hybrid search approach, combining traditional text-based search with vector similarity matching and machine learning-enhanced ranking. Each search request triggers a complex processing pipeline that includes query analysis, context enrichment, and dynamic result ranking, all while maintaining sub-second response times. Built-in performance optimization automatically balances search accuracy with response time, utilizing intelligent caching and query optimization strategies. The system adapts to search patterns in real-time, adjusting relevance calculations and ranking strategies based on user interactions and feedback. ``` typescript:src/app/api/cortex/search/route.ts export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Execute search with context and optimization const results = await services.search.execute({ query: body.query, filters: body.filters, boost: body.boost, context: { sessionId: body.sessionId, userId: body.userId, searchType: body.searchType }, pagination: { from: body.from || 0, size: body.size || 10 } }); return NextResponse.json({ success: true, data: { hits: results.hits, total: results.total, took: Date.now() - startTime, searchContext: results.context } }); } catch (error) { // Error handling with fallback strategies } } ``` **Key Capabilities:** - Hybrid search (text + vector) - Context-aware ranking - Real-time result optimization - Intelligent query processing - Automatic relevance tuning - Performance optimization The system tracks metrics about: - Query performance and latency - Result relevance scores - User interaction patterns - Cache hit rates - Resource utilization - Error rates and types - name: Cortex > A/B Testing description: >- The A/B Testing endpoints provide a sophisticated experimentation framework within Sophra's search infrastructure, enabling systematic optimization of search experiences through controlled testing. These endpoints manage the complete testing lifecycle, from variant creation to statistical analysis, while ensuring consistent user experiences and reliable data collection. The system handles test assignment, traffic allocation, and result collection automatically, maintaining strict isolation between test variants while gathering meaningful metrics. Each test can be configured with multiple variants, custom success metrics, and specific targeting rules, allowing for precise control over experimentation parameters. Built-in analytics processing provides real-time insights into test performance, automatically calculating statistical significance and identifying winning variants. The system maintains detailed logs of all test interactions, enabling deep analysis of user behavior and search performance across variants. ``` typescript:src/app/api/cortex/ab/route.ts export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Test creation with variant configuration const test = await services.abTesting.createTest({ name: body.name, variants: body.variants, trafficAllocation: body.trafficAllocation, successMetrics: body.successMetrics, targetingRules: body.targetingRules }); return NextResponse.json({ success: true, data: { testId: test.id, status: test.status, variants: test.variants, metrics: test.metrics } }); } catch (error) { // Error handling with metric tracking } } ``` **Key Capabilities:** - Multi-variant test management - Automatic traffic allocation - Real-time performance monitoring - Statistical significance calculation - User assignment and tracking - Results analysis and reporting The system tracks metrics including: - Variant performance comparisons - User engagement metrics - Conversion rates by variant - Statistical confidence levels - Test duration and sample sizes - Error rates and anomalies - name: Cortex > Analytics description: >- The Analytics endpoints serve as Sophra's comprehensive data collection and analysis system, providing deep insights into search behavior, user interactions, and system performance. These endpoints capture, process, and analyze a wide range of events and metrics, enabling data-driven optimization of search experiences and system performance. The system processes analytics events in real-time, maintaining detailed audit trails while handling high-volume data ingestion. Each analytics event is enriched with contextual information, including user session data, search parameters, and system state, providing rich datasets for analysis. The endpoints support both real-time monitoring and historical analysis, with built-in aggregation and filtering capabilities. Advanced processing pipelines automatically calculate key performance indicators, identify trends, and detect anomalies, while maintaining data consistency and accessibility. The system includes sophisticated sampling and data retention policies to manage storage efficiently while preserving analytical value. ``` typescript export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Process and store analytics event const event = await services.analytics.trackEvent({ sessionId: body.sessionId, eventType: body.eventType, timestamp: new Date(), metadata: { query: body.query, results: body.results, userActions: body.userActions, performance: body.performance } }); return NextResponse.json({ success: true, data: { eventId: event.id, processed: true, metrics: event.metrics } }); } catch (error) { // Error handling with fallback processing } } ``` **Key Features:** - Real-time event processing - User behavior tracking - Performance monitoring - Trend analysis - Anomaly detection - Custom metric calculation The system collects metrics about: - Search patterns and effectiveness - User engagement and satisfaction - System performance and reliability - Error rates and types - Resource utilization - Business impact metrics - name: Cortex > Feedback description: >- # Feedback The Feedback endpoints manage Sophra's learning mechanisms, collecting and processing user interactions and explicit feedback to continuously improve search relevance. These endpoints handle various types of feedback signals, from explicit ratings to implicit behavioral cues, incorporating them into the platform's adaptive learning system. The system processes feedback in real-time, using it to adjust search rankings, update learning models, and refine relevance calculations. Each feedback signal is contextualized with session data, search parameters, and user interactions, providing rich information for the learning pipeline. The endpoints support both immediate adjustments and long-term learning patterns, ensuring balanced optimization of search experiences. Advanced processing pipelines automatically analyze feedback patterns, identify significant trends, and trigger appropriate adaptation rules, while maintaining system stability and preventing feedback loops. The system includes sophisticated weighting mechanisms to balance different types of feedback and prevent gaming or manipulation. ``` typescript:src/app/api/cortex/feedback/route.ts export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Process feedback with context const feedback = await services.feedback.process({ sessionId: body.sessionId, resultId: body.resultId, feedbackType: body.type, score: body.score, context: { query: body.query, position: body.position, interactionTime: body.interactionTime, userActions: body.actions } }); return NextResponse.json({ success: true, data: { feedbackId: feedback.id, processed: true, impact: feedback.impact } }); } catch (error) { // Error handling with feedback preservation } } ``` **Key Features:** - Real-time feedback processing - Multi-signal feedback collection - Contextual feedback analysis - Adaptive learning integration - Feedback validation - Impact measurement The system tracks metrics about: - Feedback patterns and trends - Learning effectiveness - Adaptation impact - User satisfaction levels - System responsiveness - Feedback quality scores - name: Cortex > Metrics description: >- The Metrics endpoints serve as Sophra's central nervous system for operational monitoring, collecting and aggregating performance data across all system components. These endpoints handle comprehensive metric collection, from low-level system performance to high-level business KPIs, providing a complete view of platform health and effectiveness. The system processes metrics in real-time, supporting both push and pull collection methods while maintaining high throughput and low latency. Each metric is automatically tagged with relevant context, including service identifiers, environment information, and temporal markers, enabling precise analysis and troubleshooting. The endpoints support various metric types, from simple counters to complex histograms and distributions. Built-in aggregation pipelines automatically process raw metrics into meaningful insights, supporting both real-time monitoring and historical trend analysis. The system includes sophisticated sampling and storage optimization strategies to handle high-volume metric collection efficiently. ``` typescript export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Process and store metrics const metric = await services.metrics.record({ name: body.name, value: body.value, type: body.type, labels: body.labels, timestamp: new Date(), context: { service: body.service, environment: body.environment, instance: body.instance } }); return NextResponse.json({ success: true, data: { metricId: metric.id, processed: true, aggregations: metric.aggregations } }); } catch (error) { // Error handling with metric buffering } } ``` **Key Capabilities:** - Real-time metric collection - Multi-dimensional aggregation - Automatic tagging and context - Historical trend analysis - Alert threshold monitoring - Performance impact tracking The system tracks various metric types: - System performance metrics - Business KPIs - User experience metrics - Resource utilization - Error rates and patterns - Service health indicators - name: Nous description: "Nous serves as Sophra's intelligent adaptation\_layer, continuously learning and evolving to optimize\_search experiences. As the platform's cognitive engine, it\_processes signals from user interactions, search patterns, and system performance to\_make real-time adjustments that improve\_relevance and efficiency.\n\nAt\_its core, Nous employs sophisticated machine learning models that analyze search behaviors and outcomes. It identifies successful search patterns, learns\_from user feedback, and automatically generates adaptation\_rules to enhance future searches. Through\_comprehensive A/B testing capabilities, Nous systematically evaluates different search strategies, automatically\_promoting those that deliver the best results.\n\nThe service maintains a deep understanding of search context by\_processing multiple signal types - from explicit user feedback to\_implicit behavioral cues. These signals feed into Nous's learning pipeline, which\_continuously updates its models and adaptation\_strategies. This creates a self-improving\_system where each interaction contributes to better\_search experiences for all users.\n\nWhat\_makes Nous particularly powerful is\_its ability to balance immediate adaptations with long-term\_learning. While it can make real-time adjustments to\_search parameters based on current conditions, it also builds\_deeper understanding over time, identifying trends and patterns that inform more\_strategic optimizations. This dual approach ensures\_both immediate responsiveness and sustained improvement in search quality." - name: Nous > Health description: >- The Nous Health endpoints provide comprehensive monitoring of Sophra's intelligence layer, offering deep insights into the platform's learning systems and adaptation mechanisms. These endpoints track the health and performance of all AI components, from model serving infrastructure to learning pipeline efficiency. The system conducts continuous health checks across all intelligence components, monitoring model performance, learning effectiveness, and adaptation quality. Each health check evaluates multiple aspects of the AI infrastructure, including model latency, prediction quality, and learning convergence rates, while maintaining strict performance boundaries to ensure reliable operation. Advanced monitoring pipelines automatically detect anomalies in model behavior, identify potential degradation in learning quality, and track the effectiveness of adaptation mechanisms. The system includes sophisticated fallback strategies to maintain service quality even when components show signs of degradation. ``` typescript export async function GET(_req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); // Comprehensive AI system health check const health = { timestamp: new Date().toISOString(), models: { serving: await checkModelServing(services.models), training: await checkTrainingPipeline(services.training), adaptation: await checkAdaptationSystem(services.adaptation) }, learning: { effectiveness: await measureLearningEffectiveness(services.learning), convergence: await checkConvergenceRates(services.learning), stability: await assessSystemStability(services.learning) }, overall: false }; health.overall = Object.values(health.models).every( (component) => component.operational ); return NextResponse.json({ success: true, data: health, meta: { took: Date.now() - startTime } }); } catch (error) { // Error handling with fallback checks } } ``` **Key Features:** - AI component health monitoring - Model performance tracking - Learning quality assessment - Adaptation effectiveness measurement - System stability monitoring - Anomaly detection The system tracks metrics about: - Model serving performance - Learning pipeline health - Adaptation effectiveness - Resource utilization - Error rates and patterns - System stability indicators - name: Nous > A/B Testing description: >- # Nous A/B Testing The Nous A/B Testing endpoints manage controlled experiments for Sophra's intelligence layer, focusing on testing and validating changes to core business logic, learning algorithms, and adaptation strategies. Unlike Cortex's contextual search testing, these endpoints handle experiments that affect the platform's fundamental decision-making processes and learning behaviors. The system orchestrates sophisticated multi-variant tests of AI components, measuring the impact of different learning strategies, model configurations, and business rule sets. Each test is carefully isolated to prevent cross-contamination while maintaining system stability. The endpoints support complex experimental designs, including multi-armed bandits and sequential testing, while ensuring consistent platform performance. Built-in safeguards automatically monitor test impact on system health and user experience, with automatic rollback capabilities if predefined thresholds are breached. The system includes detailed tracking of both technical metrics and business KPIs to provide comprehensive insight into test outcomes. ``` typescript export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Create AI component test const experiment = await services.experiments.create({ name: body.name, type: body.type, // e.g., 'learning_strategy', 'model_config', 'business_rules' variants: body.variants, metrics: { technical: body.technicalMetrics, business: body.businessMetrics, guardrails: body.guardrails }, rolloutStrategy: body.rolloutStrategy, fallbackConfig: body.fallbackConfig }); return NextResponse.json({ success: true, data: { experimentId: experiment.id, status: experiment.status, monitoring: experiment.monitoring } }); } catch (error) { // Error handling with experiment safeguards } } ``` **Key Capabilities:** - AI component experimentation - Business logic testing - Learning strategy validation - Automatic safeguards - Impact isolation - Performance monitoring The system tracks metrics about: - Learning effectiveness - Business impact - System stability - Resource efficiency - Error patterns - User experience impact - name: Nous > Adaptation description: >- # Adaptation The Adaptation endpoints manage Sophra's intelligent system modifications, orchestrating how the platform evolves and adjusts its behavior based on accumulated learning and real-world performance data. These endpoints handle the complex process of applying learned optimizations while maintaining system stability and predictable behavior. The system implements a sophisticated adaptation pipeline that carefully validates and applies changes to various system components, from ranking algorithms to business rules. Each adaptation is versioned and monitored, with built-in capability to roll back changes that don't meet performance thresholds. The endpoints support both automated and controlled adaptation processes, allowing for different levels of human oversight. Advanced validation mechanisms ensure that adaptations improve system performance across multiple dimensions while preventing unexpected side effects. The system maintains detailed logs of all adaptations and their impacts, enabling comprehensive analysis of system evolution over time. ``` typescript:src/app/api/nous/adaptation/route.ts export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Process adaptation request const adaptation = await services.adaptation.apply({ type: body.type, // e.g., 'ranking', 'rules', 'thresholds' changes: body.changes, context: { learningSource: body.source, confidence: body.confidence, impact: body.expectedImpact }, validation: { metrics: body.validationMetrics, thresholds: body.acceptanceThresholds, rollbackTriggers: body.rollbackTriggers } }); return NextResponse.json({ success: true, data: { adaptationId: adaptation.id, status: adaptation.status, metrics: adaptation.metrics, rollbackPlan: adaptation.rollbackPlan } }); } catch (error) { // Error handling with safety fallbacks } } ``` **Key Features:** - Intelligent system adaptation - Version-controlled changes - Performance validation - Automatic rollback capability - Impact monitoring - Change auditing The system tracks metrics about: - Adaptation effectiveness - System stability - Performance impact - Learning convergence - Error rates - Business metric impacts - name: Nous > Learning description: >- The Learning endpoints orchestrate Sophra's core intelligence acquisition processes, managing how the system learns from user interactions, feedback signals, and performance data. These endpoints handle the complex task of converting raw experience into actionable intelligence while maintaining learning stability and preventing negative feedback loops. The system implements sophisticated learning pipelines that process multiple signal types simultaneously, from explicit user feedback to implicit behavioral patterns. Each learning cycle is carefully monitored and validated, ensuring that new knowledge improves system performance without compromising reliability. The endpoints support both real-time learning adjustments and batch processing of historical data. Built-in safeguards prevent the system from learning from anomalous or adversarial inputs while maintaining the ability to adapt to genuine changes in user behavior and content patterns. The system includes detailed tracking of learning effectiveness and model performance over time. ``` typescript export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Process learning event const learningEvent = await services.learning.process({ type: body.type, // e.g., 'feedback', 'behavior', 'performance' signals: body.signals, context: { source: body.source, confidence: body.confidence, sessionData: body.sessionData }, validation: { qualityMetrics: body.qualityMetrics, stabilityChecks: body.stabilityChecks, anomalyDetection: body.anomalyDetection } }); return NextResponse.json({ success: true, data: { eventId: learningEvent.id, status: learningEvent.status, impact: learningEvent.impact, qualityMetrics: learningEvent.qualityMetrics } }); } catch (error) { // Error handling with learning preservation } } ``` **Key Features:** - Multi-signal learning processing - Real-time knowledge acquisition - Learning validation - Anomaly detection - Performance monitoring - Knowledge versioning The system tracks metrics about: - Learning effectiveness - Signal quality - Model performance - System stability - Error patterns - Knowledge retention - name: Nous > Learning > Models - name: Nous > Learning > Search Patterns - name: Nous > Learning > Feedback - name: Nous > Learning > Metrics and Events - name: Nous > Signals description: >- The Signals endpoints manage Sophra's comprehensive signal collection and processing system, serving as the primary input channel for the platform's learning and adaptation mechanisms. These endpoints handle the ingestion, validation, and initial processing of all types of signals, from user interactions to system performance metrics, that drive the platform's intelligent behavior. The system implements sophisticated signal processing pipelines that handle real-time signal ingestion while maintaining data quality and processing efficiency. Each signal is automatically enriched with contextual information and validated against known patterns to ensure data integrity. The endpoints support both synchronous and asynchronous signal processing, with built-in buffering for high-volume scenarios. Advanced signal correlation mechanisms automatically identify relationships between different signal types, enabling complex pattern recognition and trend analysis. The system includes comprehensive monitoring of signal quality and processing performance to maintain reliable operation at scale. ``` typescript export async function POST(req: NextRequest): Promise { const startTime = Date.now(); try { const services = await serviceManager.getServices(); const body = await req.json(); // Process incoming signal const signal = await services.signals.process({ type: body.type, // e.g., 'user_interaction', 'system_metric', 'feedback' data: body.data, context: { source: body.source, timestamp: new Date(), sessionId: body.sessionId, environment: body.environment }, processing: { priority: body.priority, enrichment: body.enrichment, validation: body.validation } }); return NextResponse.json({ success: true, data: { signalId: signal.id, processed: signal.processed, enriched: signal.enriched, correlations: signal.correlations } }); } catch (error) { // Error handling with signal preservation } } ``` **Key Features:** - Real-time signal processing - Automatic signal enrichment - Quality validation - Pattern correlation - Priority handling - Signal buffering The system tracks metrics about: - Signal volume and types - Processing latency - Data quality - Correlation patterns - Error rates - System load paths: /cortex/analytics/search: post: tags: - Cortex > Analytics summary: Log Search Analytics requestBody: content: application/json: schema: type: object properties: query: type: string description: The search query searchType: type: string enum: - text - vector - hybrid description: Type of search performed totalHits: type: integer description: Total number of search results took: type: integer description: Time taken to perform the search in milliseconds sessionId: type: string description: Session identifier facets: type: object properties: authors: type: array items: type: string tags: type: array items: type: string yearPublished: type: object properties: min: type: integer max: type: integer source: type: array items: type: string selectedFilters: type: object properties: contentType: type: string language: type: string hasCode: type: boolean required: - query - searchType - sessionId example: query: machine learning optimization searchType: hybrid totalHits: 150 took: 234 sessionId: sess_abc123 facets: authors: - John Smith - Jane Doe tags: - AI - ML yearPublished: min: 2020 max: 2024 source: - arXiv - IEEE selectedFilters: contentType: research-paper language: en hasCode: true responses: '201': description: Search analytics logged successfully ````