Upload 7 files

config/environment.json

@@ -0,0 +1,7 @@
+{
+  "cuda_available": false,
+  "gpu_count": 0,
+  "gpu_memory": 0,
+  "python_version": "3.13.7",
+  "torch_version": "2.8.0+cpu"
+}

config/models.json

@@ -0,0 +1,44 @@
+{
+    "models": {
+        "phi": {
+            "path": "microsoft/phi-3-mini-4k-instruct",
+            "description": "Efficient model good for general tasks",
+            "requirements": {
+                "min_ram": "8GB",
+                "recommended_gpu": "4GB VRAM"
+            }
+        },
+        "mistral": {
+            "path": "mistralai/Mistral-7B-v0.1",
+            "description": "Excellent for reasoning and technical content",
+            "requirements": {
+                "min_ram": "16GB",
+                "recommended_gpu": "8GB VRAM"
+            }
+        },
+        "codellama": {
+            "path": "codellama/CodeLlama-7b-instruct-hf",
+            "description": "Specialized for code understanding and generation",
+            "requirements": {
+                "min_ram": "16GB",
+                "recommended_gpu": "8GB VRAM"
+            }
+        },
+        "llama": {
+            "path": "meta-llama/Llama-3.1-8B-instruct",
+            "description": "Powerful general-purpose model",
+            "requirements": {
+                "min_ram": "16GB",
+                "recommended_gpu": "12GB VRAM"
+            }
+        }
+    },
+    "default_model": "phi",
+    "load_in_8bit": true,
+    "device_map": "auto",
+    "max_memory": null,
+    "torch_dtype": "float16",
+    "model_auth_required": {
+        "meta-llama": true
+    }
+}

docs/configuration.md

@@ -0,0 +1,54 @@
+# Codette Configuration Guide
+
+## Environment Variables
+
+- `HUGGINGFACEHUB_API_TOKEN`: HuggingFace API token for sentiment analysis and model access
+- `OPENAI_API_KEY`: Optional OpenAI API key for additional model support
+- `LOG_LEVEL`: Logging level (DEBUG, INFO, WARNING, ERROR)
+- `PORT`: Port number for the web server (default: 7860)
+
+## Model Configuration
+
+Codette supports multiple language models in a fallback chain:
+
+1. Mistral-7B-Instruct (Primary)
+   - 7B parameter instruction-tuned model
+   - Requires 16GB+ VRAM
+   - Configuration: 8-bit quantization, fp16
+
+2. Phi-2 (Secondary)
+   - Lightweight yet powerful alternative
+   - Requires 8GB+ VRAM
+   - Configuration: fp16
+
+3. GPT-2 (Fallback)
+   - Minimal requirements
+   - Always available option
+   - Configuration: Standard loading
+
+## Consciousness Parameters
+
+### Memory System
+- `response_memory`: Maintains last 50 responses
+- `memory_context`: Uses last 5 responses for learning
+- `memory_synthesis`: Uses last 2 responses for consciousness
+
+### Quantum States
+- Stored in .cocoon files
+- Format: JSON with quantum_state and chaos_state arrays
+- Used for creative and probabilistic reasoning
+
+### Perspective System
+- Newton: temperature = 0.3 (analytical)
+- Da Vinci: temperature = 0.9 (creative)
+- Human Intuition: temperature = 0.7 (empathetic)
+- Quantum Computing: temperature = 0.8 (probabilistic)
+
+## Response Generation
+
+### Text Generation Parameters
+- Max length: 512 tokens (default)
+- Temperature range: 0.3 - 0.9
+- Top-p: 0.9
+- Context window: 2048 tokens
+- Special token handling for different models

docs/source/configuration.rst

@@ -0,0 +1,46 @@
+Configuration
+=============
+
+.. _configuration:
+
+Environment Variables
+-------------------
+
+The following environment variables can be used to configure Codette:
+
+- ``HUGGINGFACEHUB_API_TOKEN``: HuggingFace API token
+- ``OPENAI_API_KEY``: Optional OpenAI API key
+- ``LOG_LEVEL``: Logging level
+- ``PORT``: Web server port
+
+Model Configuration
+-----------------
+
+Codette uses a fallback chain of models:
+
+1. Mistral-7B-Instruct (Primary)
+2. Phi-2 (Secondary)
+3. GPT-2 (Fallback)
+
+See :class:`src.ai_core.AICore` for implementation details.
+
+Consciousness System
+------------------
+
+Memory Management
+~~~~~~~~~~~~~~~
+
+- Response memory: Last 50 responses
+- Memory context: Last 5 responses for learning
+- Memory synthesis: Last 2 responses for consciousness
+
+Quantum States
+~~~~~~~~~~~~
+
+Stored in .cocoon files with:
+
+- quantum_state arrays
+- chaos_state arrays
+- perspective information
+
+See :meth:`src.ai_core.AICore.load_cocoon_data` for details.

docs/source/index.rst

@@ -0,0 +1,44 @@
+Codette Universal Reasoning Framework
+===================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   getting_started
+   configuration
+   api/modules
+   development/contributing
+
+Core Components
+-------------
+
+AICore
+~~~~~~
+
+.. automodule:: src.ai_core
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Bot Integration
+~~~~~~~~~~~~~~
+
+.. automodule:: src.bot
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Web Application
+~~~~~~~~~~~~~~
+
+.. automodule:: src.app
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Development
+----------
+
+* :ref:`contributing`
+* :ref:`testing`

models/fallback/__init__.py

@@ -0,0 +1,110 @@
+"""
+Fallback model handler for Codette
+Uses open source models as fallbacks when proprietary models are unavailable
+"""
+import os
+from typing import Optional, Dict, Any
+import json
+import logging
+from pathlib import Path
+import numpy as np
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class FallbackModelManager:
+    def __init__(self):
+        self.models_dir = Path(__file__).parent
+        self.fallback_dir = self.models_dir / 'fallback'
+        self.fallback_dir.mkdir(exist_ok=True)
+        self.model_cache: Dict[str, Any] = {}
+        
+    def get_model(self, model_name: str) -> Optional[Any]:
+        """Get a model, falling back to open source alternatives if needed."""
+        try:
+            # Try loading the original model first
+            if model_name in self.model_cache:
+                return self.model_cache[model_name]
+                
+            original_path = self.models_dir / f"{model_name}.pt"
+            if original_path.exists():
+                import torch
+                model = torch.load(original_path)
+                self.model_cache[model_name] = model
+                return model
+                
+            # If original fails, try fallback
+            return self._load_fallback(model_name)
+            
+        except Exception as e:
+            logger.error(f"Error loading model {model_name}: {str(e)}")
+            return self._load_fallback(model_name)
+            
+    def _load_fallback(self, model_name: str) -> Optional[Any]:
+        """Load an open source fallback model."""
+        try:
+            if model_name.startswith('nlp_'):
+                from transformers import AutoModel, AutoTokenizer
+                model_id = "bert-base-uncased"  # Default fallback
+                model = AutoModel.from_pretrained(model_id)
+                tokenizer = AutoTokenizer.from_pretrained(model_id)
+                return {'model': model, 'tokenizer': tokenizer}
+                
+            elif model_name.startswith('vision_'):
+                import torchvision.models as models
+                return models.resnet18(pretrained=True)
+                
+            elif model_name.startswith('quantum_'):
+                # For quantum models, use classical approximation
+                return self._create_quantum_approximation()
+                
+            else:
+                logger.warning(f"No fallback available for {model_name}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Error loading fallback for {model_name}: {str(e)}")
+            return None
+            
+    def _create_quantum_approximation(self) -> Any:
+        """Create a classical approximation of quantum operations."""
+        try:
+            import torch
+            import torch.nn as nn
+            
+            class QuantumApproximator(nn.Module):
+                def __init__(self):
+                    super().__init__()
+                    self.layers = nn.Sequential(
+                        nn.Linear(64, 128),
+                        nn.ReLU(),
+                        nn.Linear(128, 64)
+                    )
+                    
+                def forward(self, x):
+                    return self.layers(x)
+                    
+            return QuantumApproximator()
+            
+        except Exception as e:
+            logger.error(f"Error creating quantum approximation: {str(e)}")
+            return None
+
+    def download_if_needed(self, model_name: str):
+        """Download model files if they don't exist."""
+        try:
+            if not (self.fallback_dir / f"{model_name}.pt").exists():
+                if model_name.startswith('nlp_'):
+                    from transformers import AutoModel, AutoTokenizer
+                    model_id = "bert-base-uncased"
+                    AutoModel.from_pretrained(model_id)
+                    AutoTokenizer.from_pretrained(model_id)
+                elif model_name.startswith('vision_'):
+                    import torchvision.models as models
+                    models.resnet18(pretrained=True)
+        except Exception as e:
+            logger.error(f"Error downloading model {model_name}: {str(e)}")
+
+# Global instance
+fallback_manager = FallbackModelManager()

models/fallback/model_config.json

@@ -0,0 +1,36 @@
+{
+    "model_mappings": {
+        "nlp_transformer": {
+            "fallback": "bert-base-uncased",
+            "type": "nlp",
+            "task": "general"
+        },
+        "vision_analyzer": {
+            "fallback": "resnet18",
+            "type": "vision",
+            "task": "classification"
+        },
+        "quantum_simulator": {
+            "fallback": "classical_approximation",
+            "type": "quantum",
+            "task": "simulation"
+        }
+    },
+    "fallback_priorities": {
+        "nlp": [
+            "bert-base-uncased",
+            "distilbert-base-uncased",
+            "roberta-base"
+        ],
+        "vision": [
+            "resnet18",
+            "mobilenet_v2",
+            "efficientnet_b0"
+        ],
+        "quantum": [
+            "classical_approximation",
+            "tensor_network",
+            "statistical_model"
+        ]
+    }
+}