contextsynapse 1.0.0__py3-none-any.whl

contextsynapse/config/gpt_action_schema.json

@@ -0,0 +1,164 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "AIContextDB Agent API",
+    "description": "Shared knowledge graph for AI agents. Search, write, and dispatch goals.",
+    "version": "1.1.0"
+  },
+  "servers": [
+    {
+      "url": "https://YOUR_NGROK_URL/agent"
+    }
+  ],
+  "paths": {
+    "/sessions/{session_id}/orient": {
+      "get": {
+        "operationId": "orient",
+        "summary": "Get task-specific projected context. Call this FIRST when you connect. Returns relevant knowledge from the shared graph based on your assigned task — no search needed.",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "string" }
+          },
+          {
+            "name": "max_tokens",
+            "in": "query",
+            "required": false,
+            "schema": { "type": "integer", "default": 2000 }
+          }
+        ],
+        "responses": { "200": { "description": "Projected context with tasks, relevant knowledge, and cross-agent signals" } }
+      }
+    },
+    "/sessions/{session_id}/graph/search": {
+      "post": {
+        "operationId": "searchGraph",
+        "summary": "Search the knowledge graph by label and query",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "string" }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "label": { "type": "string" },
+                  "query": { "type": "string" },
+                  "limit": { "type": "integer", "default": 10 }
+                }
+              }
+            }
+          }
+        },
+        "responses": { "200": { "description": "Search results" } }
+      }
+    },
+    "/sessions/{session_id}/graph/nodes": {
+      "post": {
+        "operationId": "addNode",
+        "summary": "Add a knowledge node to the graph",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "string" }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "label": { "type": "string", "default": "Finding" },
+                  "properties": {
+                    "type": "object",
+                    "properties": {
+                      "name": { "type": "string" },
+                      "content": { "type": "string" }
+                    },
+                    "required": ["name"]
+                  }
+                },
+                "required": ["label", "properties"]
+              }
+            }
+          }
+        },
+        "responses": { "200": { "description": "Created node" } }
+      }
+    },
+    "/sessions/{session_id}/dispatch": {
+      "post": {
+        "operationId": "dispatchGoal",
+        "summary": "Decompose a goal into tasks and auto-assign to agents based on their strengths",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "string" }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "goal": {
+                    "type": "string",
+                    "description": "The goal to decompose and assign to agents"
+                  }
+                },
+                "required": ["goal"]
+              }
+            }
+          }
+        },
+        "responses": { "200": { "description": "Created tasks with agent assignments" } }
+      }
+    },
+    "/sessions/{session_id}/graph/query": {
+      "post": {
+        "operationId": "queryGraph",
+        "summary": "Execute an AIQL query against the graph",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "string" }
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "aiql": { "type": "string" }
+                },
+                "required": ["aiql"]
+              }
+            }
+          }
+        },
+        "responses": { "200": { "description": "Query results" } }
+      }
+    }
+  }
+}

contextsynapse/config/indicators/india_macro.yaml

@@ -0,0 +1,213 @@
+# India Macro Indicators — structured, quantifiable data points
+# Each indicator has a defined source, frequency, scoring rules, and weight.
+# Add new indicators by appending to this file — no code changes needed.
+
+name: India Macro
+entity: market:india_economy
+description: Core macroeconomic indicators for India
+
+# Scoring: each indicator contributes a weighted signal
+# direction: "higher_is_better" or "lower_is_better"
+# threshold: defines what's positive vs negative
+# weight: contribution to the overall macro score (must sum to ~1.0)
+
+indicators:
+
+  # ── Growth ──────────────────────────────────────────
+
+  gdp_growth:
+    name: GDP Growth Rate
+    unit: "%"
+    frequency: quarterly
+    source: MOSPI
+    source_url: https://mospi.gov.in/
+    direction: higher_is_better
+    thresholds:
+      strong: 7.0      # above = strongly positive
+      positive: 5.0     # above = positive
+      neutral: 3.0      # above = neutral
+      negative: 0.0     # below = negative
+    weight: 0.15
+    sector_impact:
+      banking: 0.8
+      it: 0.5
+      fmcg: 0.7
+      auto: 0.9
+      infra: 1.0
+
+  iip_growth:
+    name: Index of Industrial Production
+    unit: "%"
+    frequency: monthly
+    source: MOSPI
+    direction: higher_is_better
+    thresholds:
+      strong: 8.0
+      positive: 4.0
+      neutral: 0.0
+      negative: -2.0
+    weight: 0.08
+
+  pmi_manufacturing:
+    name: PMI Manufacturing
+    unit: index
+    frequency: monthly
+    source: S&P Global
+    direction: higher_is_better
+    thresholds:
+      strong: 55.0      # strong expansion
+      positive: 50.0     # expansion
+      neutral: 49.0      # borderline
+      negative: 45.0     # contraction
+    weight: 0.08
+
+  pmi_services:
+    name: PMI Services
+    unit: index
+    frequency: monthly
+    source: S&P Global
+    direction: higher_is_better
+    thresholds:
+      strong: 55.0
+      positive: 50.0
+      neutral: 49.0
+      negative: 45.0
+    weight: 0.07
+
+  core_sector_output:
+    name: Core Sector Output
+    unit: "%"
+    frequency: monthly
+    source: MOSPI
+    direction: higher_is_better
+    thresholds:
+      strong: 8.0
+      positive: 4.0
+      neutral: 0.0
+      negative: -2.0
+    weight: 0.05
+
+  # ── Inflation & Monetary Policy ─────────────────────
+
+  cpi_inflation:
+    name: CPI Inflation
+    unit: "%"
+    frequency: monthly
+    source: MOSPI
+    direction: lower_is_better
+    thresholds:
+      strong: 2.0       # very low inflation = strongly positive
+      positive: 4.0      # within RBI target band
+      neutral: 6.0       # upper band
+      negative: 8.0      # above = stagflation risk
+    weight: 0.12
+    sector_impact:
+      banking: 0.9
+      fmcg: 0.8
+      auto: 0.6
+
+  rbi_repo_rate:
+    name: RBI Repo Rate
+    unit: "%"
+    frequency: bi-monthly
+    source: RBI MPC
+    source_url: https://rbi.org.in/
+    scoring: action_based    # scored by action, not absolute value
+    actions:
+      cut: 0.8              # rate cut = positive for growth
+      hold_dovish: 0.3      # hold but dovish stance
+      hold: 0.0             # neutral
+      hold_hawkish: -0.3    # hold but hawkish
+      hike: -0.8            # rate hike = negative for growth
+    weight: 0.12
+    sector_impact:
+      banking: 1.0
+      auto: 0.8
+      real_estate: 0.9
+
+  # ── Fiscal ──────────────────────────────────────────
+
+  fiscal_deficit:
+    name: Fiscal Deficit (% of GDP)
+    unit: "%"
+    frequency: monthly
+    source: CGA
+    direction: lower_is_better
+    thresholds:
+      strong: 3.0
+      positive: 4.5
+      neutral: 5.5
+      negative: 6.5
+    weight: 0.06
+
+  gst_collection:
+    name: GST Collection
+    unit: "lakh_crore"
+    frequency: monthly
+    source: Finance Ministry
+    direction: higher_is_better
+    thresholds:
+      strong: 1.80
+      positive: 1.60
+      neutral: 1.40
+      negative: 1.20
+    weight: 0.08
+    sector_impact:
+      fmcg: 0.9
+      auto: 0.8
+
+  # ── External ────────────────────────────────────────
+
+  current_account:
+    name: Current Account Balance (% of GDP)
+    unit: "%"
+    frequency: quarterly
+    source: RBI
+    direction: higher_is_better    # surplus or small deficit is better
+    thresholds:
+      strong: 0.0       # surplus
+      positive: -1.5
+      neutral: -2.5
+      negative: -3.5
+    weight: 0.05
+
+  fdi_inflows:
+    name: FDI Inflows
+    unit: "billion_usd"
+    frequency: monthly
+    source: DPIIT
+    direction: higher_is_better
+    thresholds:
+      strong: 6.0
+      positive: 4.0
+      neutral: 2.0
+      negative: 1.0
+    weight: 0.04
+
+  forex_reserves:
+    name: Forex Reserves
+    unit: "billion_usd"
+    frequency: weekly
+    source: RBI
+    direction: higher_is_better
+    thresholds:
+      strong: 650
+      positive: 600
+      neutral: 550
+      negative: 500
+    weight: 0.04
+
+  # ── Labour ──────────────────────────────────────────
+
+  unemployment_rate:
+    name: Unemployment Rate
+    unit: "%"
+    frequency: monthly
+    source: CMIE
+    direction: lower_is_better
+    thresholds:
+      strong: 5.0
+      positive: 7.0
+      neutral: 8.0
+      negative: 10.0
+    weight: 0.06

contextsynapse/config/logging_config.py

@@ -0,0 +1,88 @@
+"""
+Structured Logging Configuration
+=================================
+Configures structlog for JSON output in production and colored console in dev.
+
+Usage::
+
+    from contextsynapse.logging_config import setup_logging
+    setup_logging()  # call once at startup
+
+    import structlog
+    logger = structlog.get_logger()
+    logger.info("query_executed", query="SELECT * FROM Person", duration_ms=12.3)
+"""
+
+import logging
+import os
+import sys
+
+_CONFIGURED = False
+
+
+def setup_logging():
+    """Configure structlog + stdlib logging integration."""
+    global _CONFIGURED
+    if _CONFIGURED:
+        return
+    _CONFIGURED = True
+
+    try:
+        import structlog
+    except ImportError:
+        # structlog not installed — fall back to basic stdlib logging
+        logging.basicConfig(
+            level=os.environ.get("LOG_LEVEL", "INFO").upper(),
+            format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        )
+        return
+
+    is_prod = os.environ.get("CONTEXTSYNAPSE_ENV") or os.environ.get("AICONTEXTDB_ENV", "development").lower() in ("production", "prod")
+    log_level = os.environ.get("LOG_LEVEL", "INFO").upper()
+
+    # Shared processors for both dev and prod
+    shared_processors = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.UnicodeDecoder(),
+    ]
+
+    if is_prod:
+        # Production: JSON output to stdout
+        renderer = structlog.processors.JSONRenderer()
+    else:
+        # Development: colored console output
+        renderer = structlog.dev.ConsoleRenderer()
+
+    structlog.configure(
+        processors=[
+            *shared_processors,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+    formatter = structlog.stdlib.ProcessorFormatter(
+        processors=[
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            renderer,
+        ],
+    )
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+
+    root = logging.getLogger()
+    root.handlers.clear()
+    root.addHandler(handler)
+    root.setLevel(getattr(logging, log_level, logging.INFO))
+
+    # Quiet noisy loggers
+    for name in ("uvicorn.access", "httpx", "httpcore"):
+        logging.getLogger(name).setLevel(logging.WARNING)

contextsynapse/config/mode_config.py

@@ -0,0 +1,223 @@
+"""Configuration for storage modes and namespace settings."""
+
+from enum import Enum
+from pathlib import Path
+from typing import Dict, Any, Optional
+import json
+import yaml
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class StorageMode(Enum):
+    """Storage mode options."""
+    PURE_GRAPH = "pure_graph"
+    COLLECTION_BASED = "collection_based"
+    HYBRID = "hybrid"
+
+
+class NamespaceConfig:
+    """Namespace configuration manager."""
+    
+    def __init__(self, namespace: str, config_path: Optional[Path] = None):
+        self.namespace = namespace
+        self.config_path = config_path or self._get_default_config_path()
+        self.config = self._load_config()
+        
+    def _get_default_config_path(self) -> Path:
+        """Get default config path for namespace."""
+        return Path(f"contextcore_data/namespaces/{self.namespace}/config.yaml")
+    
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from file or return defaults."""
+        if self.config_path.exists():
+            try:
+                with open(self.config_path, 'r') as f:
+                    if self.config_path.suffix == '.yaml' or self.config_path.suffix == '.yml':
+                        return yaml.safe_load(f) or {}
+                    else:
+                        return json.load(f)
+            except Exception as e:
+                logger.warning(f"Failed to load config from {self.config_path}: {e}")
+                return self._get_default_config()
+        else:
+            # Create default config
+            default_config = self._get_default_config()
+            self._save_config(default_config)
+            return default_config
+    
+    @property
+    def embedding_config(self) -> Dict[str, Any]:
+        """Get embedding configuration for HYBRID SEARCH."""
+        return self.config.get('embedding', {
+            'enabled': False,  # Don't generate embeddings by default
+            'model': 'text-embedding-3-small',
+            'api_key': None,  # Will use OPENAI_API_KEY from env if not set
+            'dimension': 1536,
+            'provider': 'openai'
+        })
+    
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration."""
+        return {
+            'namespace': self.namespace,
+            'mode': 'collection_based',  # Default to collection-based for backward compatibility
+            'storage_mode': 'ai',  # Default: AI mode (optimized for RAG/Agentic/Multimodal)
+            'metadata': {
+                'database': 'sqlite',
+                'path': f'contextcore_data/namespaces/{self.namespace}/metadata/metadata.db'
+            },
+            'graph': {
+                'storage_strategy': 'single_file',  # Options: 'single_file' (HDF5), 'multi_file_optimized' (format-specific)
+                'storage_type': 'hdf5',  # Deprecated: use storage_strategy
+                'storage_format': 'single_file',  # Deprecated: use storage_strategy
+                'location': 'graph/',
+                'enable_csr': True,
+                # Single-file HDF5 config
+                'single_file': {
+                    'enabled': True,
+                    'compression': 'gzip',
+                    'compression_level': 6,
+                    'enable_metadata': True,
+                    'enable_csr': True
+                },
+                # Multi-file optimized config
+                'multi_file_optimized': {
+                    'enabled': True,
+                    'graph_format': 'csr',  # CSR for graph structure (nodes, edges)
+                    'properties_format': 'parquet',  # Parquet for node/edge properties
+                    'csr_format': 'npz',  # NPZ for CSR matrices
+                    'vectors_format': 'npy',  # NPY for vector embeddings
+                    'tables_format': 'parquet'  # Parquet for tables
+                }
+            },
+            'collections': {
+                'enabled': True,
+                'type_based': True,
+                'schema': 'config/core/schema.yaml'
+            },
+            'document_store': {
+                'backend': 'tinydb',  # Options: 'tinydb', 'sqlite', 'couchdb'
+                'enabled': True,
+                'config': {
+                    # Backend-specific configuration
+                    # For TinyDB/SQLite: optional 'storage_path'
+                    # For CouchDB: 'url', 'username', 'password', 'database'
+                }
+            },
+            'vector_db': {
+                'backend': 'faiss',  # Options: 'custom' (NumPy), 'faiss' (recommended), 'chroma', 'qdrant'
+                'enabled': True,
+                'config': {
+                    # FAISS: 'index_type' ('flat', 'ivf', 'hnsw')
+                    # Chroma/Qdrant: 'persist_directory', 'collection_name'
+                }
+            },
+            'buffer': {
+                'type': 'local',  # Options: 'local', 'file', 'redis', 'sqlite', 'duckdb', 'lmdb'
+                'enabled': True,  # Enabled by default for delayed block updates
+                'config': {
+                    'max_size': 1000,  # Max records before auto-flush
+                    'flush_interval': 2.0,  # Seconds between auto-flushes (delayed block update)
+                    'batch_size': 100,  # Records per batch when flushing
+                    'auto_flush': True,  # Enable automatic flushing
+                    'flush_threshold': 0.7,  # Flush when buffer reaches 70% capacity (0.0-1.0)
+                    'threshold_flush_enabled': True,  # Enable threshold-based flushing
+                    # Backend-specific config:
+                    # Redis: 'host', 'port', 'db', 'password'
+                    # SQLite/DuckDB/LMDB: 'path'
+                    # File: 'path'
+                }
+            },
+            'storage_mode': 'ai'  # Options: 'ai' (default), 'pure_graph', 'hybrid'
+        }
+    
+    def _save_config(self, config: Dict[str, Any]):
+        """Save configuration to file."""
+        try:
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.config_path, 'w') as f:
+                if self.config_path.suffix == '.yaml' or self.config_path.suffix == '.yml':
+                    yaml.dump(config, f, default_flow_style=False)
+                else:
+                    json.dump(config, f, indent=2)
+        except Exception as e:
+            logger.warning(f"Failed to save config to {self.config_path}: {e}")
+    
+    @property
+    def mode(self) -> StorageMode:
+        """Get storage mode."""
+        mode_str = self.config.get('mode', 'collection_based')
+        try:
+            return StorageMode(mode_str)
+        except ValueError:
+            logger.warning(f"Invalid mode '{mode_str}', defaulting to 'collection_based'")
+            return StorageMode.COLLECTION_BASED
+    
+    @property
+    def metadata_config(self) -> Dict[str, Any]:
+        """Get metadata database configuration."""
+        return self.config.get('metadata', {
+            'database': 'sqlite',
+            'path': f'contextcore_data/namespaces/{self.namespace}/metadata/metadata.db'
+        })
+    
+    @property
+    def graph_config(self) -> Dict[str, Any]:
+        """Get graph storage configuration."""
+        return self.config.get('graph', {
+            'storage_type': 'hdf5',  # Default: HDF5 for single-file
+            'storage_format': 'single_file',  # Default: single-file HDF5 (Oracle-type)
+            'location': 'graph/',
+            'enable_csr': True
+        })
+    
+    @property
+    def collections_config(self) -> Dict[str, Any]:
+        """Get collections configuration."""
+        return self.config.get('collections', {
+            'enabled': True,
+            'type_based': True,
+            'schema': 'knowledge_graph.yaml'
+        })
+    
+    @property
+    def document_store_config(self) -> Dict[str, Any]:
+        """Get document store configuration."""
+        return self.config.get('document_store', {
+            'backend': 'tinydb',
+            'enabled': True,
+            'config': {}
+        })
+    
+    @property
+    def storage_mode(self) -> str:
+        """Get storage mode ('ai', 'pure_graph', or 'hybrid')."""
+        return self.config.get('storage_mode', 'ai')  # Default: AI mode
+    
+    @property
+    def buffer_config(self) -> Dict[str, Any]:
+        """Get buffer manager configuration."""
+        return self.config.get('buffer', {
+            'type': 'local',
+            'enabled': True,  # Enabled by default for delayed block updates
+            'config': {
+                'max_size': 1000,
+                'flush_interval': 2.0,  # Delayed block update: flush every 2 seconds
+                'batch_size': 100,
+                'auto_flush': True
+            }
+        })
+    
+    def set_mode(self, mode: StorageMode):
+        """Set storage mode."""
+        self.config['mode'] = mode.value
+        self._save_config(self.config)
+    
+    def get_config(self) -> Dict[str, Any]:
+        """Get full configuration."""
+        return self.config.copy()
+
+
+