# Ubuntu/Debian
sudo apt update
sudo apt install python3.11 python3.11-venv python3-pip

# macOS (using Homebrew)
brew install python@3.11

# Windows (using winget)
winget install Python.Python.3.11

# Ubuntu/Debian
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

# macOS
brew install node@20

# Windows
winget install OpenJS.NodeJS

# Ubuntu/Debian
sudo apt install docker.io docker-compose
sudo systemctl start docker
sudo usermod -aG docker $USER

# macOS
brew install --cask docker

# Windows
winget install Docker.DockerDesktop

# Ubuntu/Debian
sudo apt install git

# macOS
brew install git

# Windows
winget install Git.Git

mkdir simulacra-system
cd simulacra-system

# Create main directories
mkdir -p backend frontend docs old reddit_export

# Create backend subdirectories
mkdir -p backend/src/{api,agents,core,database,ingestion,nlp,persona,multimodal}
mkdir -p backend/src/api/{routes,models,schemas}
mkdir -p backend/src/agents/{researcher,writer,critic,orchestrator}
mkdir -p backend/src/nlp/{extraction,embeddings}
mkdir -p backend/src/persona/{extraction,prompting,evolution}
mkdir -p backend/src/multimodal/{image,voice}

# Create frontend subdirectories
mkdir -p frontend/src/{app,components,hooks,lib,types}
mkdir -p frontend/src/app/{dashboard,personas,graph,chat,ingestion}/page.tsx
mkdir -p frontend/public

cd backend

# Create virtual environment
python3.11 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Upgrade pip
pip install --upgrade pip

# Web frameworks
pip install fastapi==0.104.1 uvicorn[standard]==0.24.0 django==4.2.7 djangorestframework==3.14.0

# Database dependencies
pip install neo4j==5.17.0 chromadb==0.4.18 psycopg2-binary==2.9.7 sqlalchemy==2.0.23

# LLM and AI dependencies
pip install ollama==0.2.1 langchain==0.1.0 langchain-community==0.0.10

# Data processing
pip install feedparser==6.0.10 praw==7.7.1 newspaper3k==0.2.8 beautifulsoup4==4.12.2 lxml==4.9.3

# Multi-agent orchestration
pip install crewai==0.1.0 autogen==0.2.0 smolagents==0.1.0

# Image generation
pip install diffusers==0.25.0 transformers==4.35.2 torch==2.1.1 accelerate==0.25.0

# Voice synthesis
pip install coqui-tts==0.22.0 edge-tts==6.1.10

# Data validation and processing
pip install pydantic==2.5.0 pydantic-core==2.14.5 pandas==2.1.4 numpy==1.24.3 scikit-learn==1.3.2

# Async operations
pip install aiohttp==3.9.1 httpx==0.25.2 celery==5.3.4 redis==5.0.1

pip freeze > requirements.txt

# Install Django and create project
pip install django djangorestframework
django-admin startproject config .
python manage.py startapp api
python manage.py startapp personas

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

SECRET_KEY = os.getenv('SECRET_KEY', 'your-secret-key-here')
DEBUG = os.getenv('DEBUG', 'True').lower() == 'true'

ALLOWED_HOSTS = ['*']

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'api',
    'personas',
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.getenv('POSTGRES_DB', 'simulacra'),
        'USER': os.getenv('POSTGRES_USER', 'user'),
        'PASSWORD': os.getenv('POSTGRES_PASSWORD', 'password'),
        'HOST': os.getenv('POSTGRES_HOST', 'localhost'),
        'PORT': os.getenv('POSTGRES_PORT', '5432'),
    }
}

# ... rest of settings

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from .routes import ingestion, graph, agents, persona, multimodal

app = FastAPI(title="Simulacra System API", version="1.0.0")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Include routers
app.include_router(ingestion.router, prefix="/api/ingestion", tags=["ingestion"])
app.include_router(graph.router, prefix="/api/graph", tags=["graph"])
app.include_router(agents.router, prefix="/api/agents", tags=["agents"])
app.include_router(persona.router, prefix="/api/persona", tags=["persona"])
app.include_router(multimodal.router, prefix="/api/multimodal", tags=["multimodal"])

@app.get("/health")
async def health_check():
    return {"status": "healthy"}

# Ubuntu/Debian
sudo apt install postgresql postgresql-contrib
sudo systemctl start postgresql
sudo -u postgres createuser --createdb --superuser simulacra
sudo -u postgres createdb simulacra
sudo -u postgres psql -c "ALTER USER simulacra PASSWORD 'password';"

# macOS
brew install postgresql
brew services start postgresql
createdb simulacra

# Download and install Neo4j
wget -O - https://debian.neo4j.com/neotechnology.gpg.key | sudo apt-key add -
echo 'deb https://debian.neo4j.com/ stable latest' | sudo tee /etc/apt/sources.list.d/neo4j.list
sudo apt update
sudo apt install neo4j=1:5.17.0

# Start Neo4j
sudo systemctl start neo4j
sudo systemctl enable neo4j

# Set password
curl -X POST -H "Content-Type: application/json" \
  -d '{"password":"password"}' \
  http://localhost:7474/user/neo4j/password

pip install chromadb

cd frontend

# Create Next.js app with TypeScript
npx create-next-app@latest . --typescript --tailwind --eslint --app --src-dir --import-alias "@/*" --yes

# Install additional dependencies
npm install @radix-ui/react-dialog @radix-ui/react-dropdown-menu @radix-ui/react-select \
  @radix-ui/react-toast @radix-ui/react-card @radix-ui/react-button @radix-ui/react-input \
  @radix-ui/react-textarea @radix-ui/react-badge @radix-ui/react-tabs @radix-ui/react-progress \
  reactflow @reactflow/core d3 zustand @tanstack/react-query \
  react-hook-form zod @hookform/resolvers framer-motion lucide-react \
  wavesurfer.js

{
  "compilerOptions": {
    "target": "es5",
    "lib": ["dom", "dom.iterable", "es6"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict": true,
    "noEmit": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "preserve",
    "incremental": true,
    "plugins": [
      {
        "name": "next"
      }
    ],
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    }
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
  "exclude": ["node_modules"]
}

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: [
    './src/pages/**/*.{js,ts,jsx,tsx,mdx}',
    './src/components/**/*.{js,ts,jsx,tsx,mdx}',
    './src/app/**/*.{js,ts,jsx,tsx,mdx}',
  ],
  theme: {
    extend: {
      colors: {
        // Custom color palette for Simulacra
        primary: {
          50: '#f0f9ff',
          500: '#3b82f6',
          600: '#2563eb',
          900: '#1e3a8a',
        },
        // ... add more colors
      },
    },
  },
  plugins: [],
}

import asyncio
from typing import List, Dict, Any
from datetime import datetime
import feedparser
import praw
from newspaper import Article
from bs4 import BeautifulSoup
import aiohttp

class KnowledgeIngestionPipeline:
    def __init__(self):
        self.sources = []
        self.chunker = SlidingWindowChunker(window_size=512, overlap=128)
        self.entity_extractor = EntityExtractor()
        self.relation_extractor = RelationExtractor()
        self.embedder = SentenceTransformerEmbedder()

    async def ingest_rss_feed(self, url: str) -> List[Dict[str, Any]]:
        """Ingest articles from RSS feed"""
        feed = feedparser.parse(url)
        articles = []

        for entry in feed.entries:
            try:
                article = Article(entry.link)
                article.download()
                article.parse()

                processed_article = {
                    'title': article.title,
                    'content': article.text,
                    'url': entry.link,
                    'published': entry.published_parsed,
                    'source': 'rss',
                    'metadata': {
                        'feed_url': url,
                        'authors': article.authors,
                        'summary': article.summary
                    }
                }
                articles.append(processed_article)
            except Exception as e:
                print(f"Error processing article {entry.link}: {e}")
                continue

        return articles

    async def ingest_reddit_content(self, subreddit: str, limit: int = 100) -> List[Dict[str, Any]]:
        """Ingest content from Reddit"""
        reddit = praw.Reddit(
            client_id=os.getenv('REDDIT_CLIENT_ID'),
            client_secret=os.getenv('REDDIT_CLIENT_SECRET'),
            user_agent='SimulacraSystem/1.0'
        )

        posts = []
        subreddit_obj = reddit.subreddit(subreddit)

        for post in subreddit_obj.hot(limit=limit):
            processed_post = {
                'title': post.title,
                'content': post.selftext,
                'url': post.url,
                'score': post.score,
                'num_comments': post.num_comments,
                'created_utc': post.created_utc,
                'source': 'reddit',
                'metadata': {
                    'subreddit': subreddit,
                    'author': str(post.author)
                }
            }
            posts.append(processed_post)

        return posts

    def process_documents(self, documents: List[Dict[str, Any]]) -> List[ProcessedDocument]:
        """Process documents through the full pipeline"""
        processed_docs = []

        for doc in documents:
            # Chunk text
            chunks = self.chunker.chunk(doc['content'])

            # Extract entities and relations
            entities = []
            relations = []
            for chunk in chunks:
                chunk_entities = self.entity_extractor.extract(chunk)
                chunk_relations = self.relation_extractor.extract(chunk, chunk_entities)
                entities.extend(chunk_entities)
                relations.extend(chunk_relations)

            # Generate embeddings
            embeddings = self.embedder.encode(chunks)

            processed_doc = ProcessedDocument(
                original_doc=doc,
                chunks=chunks,
                entities=entities,
                relations=relations,
                embeddings=embeddings
            )
            processed_docs.append(processed_doc)

        return processed_docs

from neo4j import GraphDatabase
from typing import List, Dict, Any

class Neo4jGraphStore:
    def __init__(self, uri: str, user: str, password: str):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def create_node(self, label: str, properties: Dict[str, Any]) -> str:
        """Create a node in the graph"""
        with self.driver.session() as session:
            result = session.run(
                f"CREATE (n:{label} $properties) RETURN id(n)",
                properties=properties
            )
            return result.single()[0]

    def create_relationship(self, start_id: int, end_id: int,
                          relationship_type: str, properties: Dict[str, Any] = None):
        """Create a relationship between nodes"""
        props = properties or {}
        with self.driver.session() as session:
            session.run(
                f"MATCH (a), (b) WHERE id(a) = $start_id AND id(b) = $end_id "
                f"CREATE (a)-[r:{relationship_type} $properties]->(b)",
                start_id=start_id, end_id=end_id, properties=props
            )

    def search_nodes(self, query: str, limit: int = 10) -> List[Dict[str, Any]]:
        """Search for nodes using Cypher query"""
        with self.driver.session() as session:
            result = session.run(query)
            return [dict(record) for record in result][:limit]

import spacy
from typing import Dict, List, Any
import numpy as np
from sklearn.preprocessing import StandardScaler

class TraitExtractor:
    def __init__(self):
        self.nlp = spacy.load("en_core_web_sm")
        self.traits = [
            'skepticism', 'empathy', 'vocabulary_complexity', 'humor_sarcasm',
            'formality', 'curiosity', 'directness', 'analytical_thinking',
            'emotional_expression', 'creativity'
        ]

    def extract_traits(self, texts: List[str]) -> Dict[str, float]:
        """Extract personality traits from text samples"""
        features = []

        for text in texts:
            doc = self.nlp(text)

            # Linguistic features
            avg_sentence_length = np.mean([len(sent) for sent in doc.sents])
            vocab_richness = len(set([token.lemma_.lower() for token in doc if token.is_alpha])) / len([token for token in doc if token.is_alpha])

            # Stylistic features
            question_ratio = len([sent for sent in doc.sents if sent.text.strip().endswith('?')]) / len(list(doc.sents))
            exclamation_ratio = len([token for token in doc if token.text == '!']) / len(list(doc))

            features.append([
                avg_sentence_length,
                vocab_richness,
                question_ratio,
                exclamation_ratio,
                # Add more features...
            ])

        # Normalize features
        scaler = StandardScaler()
        normalized_features = scaler.fit_transform(features)

        # Map to traits (simplified mapping)
        trait_scores = {}
        for i, trait in enumerate(self.traits):
            if i < len(normalized_features[0]):
                trait_scores[trait] = float(np.mean(normalized_features[:, i]))
            else:
                trait_scores[trait] = 0.5  # Default value

        # Normalize to 0-1 range
        for trait in trait_scores:
            trait_scores[trait] = (trait_scores[trait] + 3) / 6  # Assuming features are roughly normal
            trait_scores[trait] = max(0.0, min(1.0, trait_scores[trait]))

        return trait_scores

from typing import Dict, Any
import json

class PromptEngine:
    def __init__(self):
        self.templates = {
            'conversation': """
You are role-playing as {persona_name}. Your personality traits are:
{trait_descriptions}

Communication guidelines:
- Skepticism: {skepticism:.1f}/1.0
- Directness: {directness:.1f}/1.0
- Humor: {humor:.1f}/1.0

Current context: {context}

Respond naturally while embodying these traits.
""",
            'analysis': """
Analyze the following content from the perspective of {persona_name}:

Personality traits: {trait_descriptions}

Content to analyze: {content}

Provide insights that reflect {persona_name}'s personality and thought patterns.
"""
        }

    def generate_prompt(self, template_name: str, persona_traits: Dict[str, float],
                       context: Dict[str, Any]) -> str:
        """Generate a context-aware prompt"""

        # Format trait descriptions
        trait_descriptions = []
        for trait, value in persona_traits.items():
            trait_descriptions.append(f"- {trait}: {value:.2f}")
        trait_descriptions_str = "\n".join(trait_descriptions)

        # Get template
        template = self.templates.get(template_name, self.templates['conversation'])

        # Fill template
        prompt = template.format(
            persona_name=context.get('persona_name', 'Unknown'),
            trait_descriptions=trait_descriptions_str,
            skepticism=persona_traits.get('skepticism', 0.5),
            directness=persona_traits.get('directness', 0.5),
            humor=persona_traits.get('humor_sarcasm', 0.5),
            context=context.get('conversation_context', ''),
            content=context.get('content', '')
        )

        return prompt

from abc import ABC, abstractmethod
from typing import Dict, Any, Optional
import asyncio

class BaseAgent(ABC):
    def __init__(self, name: str, role: str):
        self.name = name
        self.role = role

    @abstractmethod
    async def execute(self, task: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """Execute the agent's task"""
        pass

    def validate_input(self, input_data: Dict[str, Any]) -> bool:
        """Validate input data"""
        return True

    def validate_output(self, output_data: Dict[str, Any]) -> bool:
        """Validate output data"""
        return True

import networkx as nx
from typing import Dict, Any, List
from ..base import BaseAgent

class OrchestratorAgent(BaseAgent):
    def __init__(self):
        super().__init__("orchestrator", "Workflow coordination and task decomposition")
        self.agents = {}
        self.execution_graph = nx.DiGraph()

    def register_agent(self, agent: BaseAgent):
        """Register an agent for orchestration"""
        self.agents[agent.name] = agent

    async def execute(self, task: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """Execute complex task through agent orchestration"""

        # Decompose task into subtasks
        subtasks = self._decompose_task(task)

        # Create execution plan
        execution_plan = self._create_execution_plan(subtasks)

        # Execute plan
        results = {}
        for step in execution_plan:
            agent_name = step['agent']
            agent = self.agents[agent_name]

            # Gather inputs from previous steps
            inputs = self._gather_inputs(step, results)

            # Execute agent task
            result = await agent.execute(inputs, context)
            results[agent_name] = result

        # Synthesize final result
        final_result = self._synthesize_results(results, task)

        return final_result

    def _decompose_task(self, task: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Break down complex task into manageable subtasks"""
        task_type = task.get('type', 'general')

        if task_type == 'research_and_write':
            return [
                {'agent': 'researcher', 'task': 'gather_information', 'query': task['query']},
                {'agent': 'writer', 'task': 'synthesize_content', 'style': task.get('style', 'neutral')},
                {'agent': 'critic', 'task': 'review_content', 'criteria': ['accuracy', 'clarity', 'engagement']}
            ]
        elif task_type == 'analysis':
            return [
                {'agent': 'researcher', 'task': 'analyze_topic', 'topic': task['topic']},
                {'agent': 'writer', 'task': 'create_summary', 'format': task.get('format', 'detailed')}
            ]
        else:
            return [{'agent': 'writer', 'task': 'general_response', 'content': task['content']}]

    def _create_execution_plan(self, subtasks: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """Create ordered execution plan with dependencies"""
        # Simple sequential execution for now
        plan = []
        for i, subtask in enumerate(subtasks):
            plan.append({
                'step': i,
                'agent': subtask['agent'],
                'task': subtask,
                'dependencies': [j for j in range(i) if j < i]  # All previous steps
            })
        return plan

    def _gather_inputs(self, step: Dict[str, Any], results: Dict[str, Any]) -> Dict[str, Any]:
        """Gather inputs for current step from previous results"""
        inputs = step['task'].copy()

        # Add results from dependency steps
        for dep_step in step['dependencies']:
            dep_agent = self.execution_plan[dep_step]['agent']
            if dep_agent in results:
                inputs[f"{dep_agent}_output"] = results[dep_agent]

        return inputs

    def _synthesize_results(self, results: Dict[str, Any], original_task: Dict[str, Any]) -> Dict[str, Any]:
        """Synthesize final result from all agent outputs"""
        if 'critic' in results:
            # Use critic feedback to refine final output
            final_output = results['writer']['content']
            feedback = results['critic'].get('feedback', [])

            # Apply feedback (simplified)
            for suggestion in feedback:
                if suggestion['type'] == 'improvement':
                    # Apply improvement logic here
                    pass

            return {
                'content': final_output,
                'feedback_applied': len(feedback),
                'quality_score': results['critic'].get('score', 0.5)
            }
        else:
            return results.get('writer', results.get('researcher', {'content': 'Task completed'}))

'use client'

import { useState, useEffect } from 'react'
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
import { Button } from '@/components/ui/button'
import { Badge } from '@/components/ui/badge'

export default function Dashboard() {
  const [systemStatus, setSystemStatus] = useState<any>(null)
  const [recentActivity, setRecentActivity] = useState<any[]>([])

  useEffect(() => {
    fetchSystemStatus()
    fetchRecentActivity()
  }, [])

  const fetchSystemStatus = async () => {
    try {
      const response = await fetch('/api/health')
      const data = await response.json()
      setSystemStatus(data)
    } catch (error) {
      console.error('Failed to fetch system status:', error)
    }
  }

  const fetchRecentActivity = async () => {
    try {
      const response = await fetch('/api/activity/recent')
      const data = await response.json()
      setRecentActivity(data)
    } catch (error) {
      console.error('Failed to fetch recent activity:', error)
    }
  }

  return (
    <div className="container mx-auto p-6">
      <div className="mb-8">
        <h1 className="text-3xl font-bold">Simulacra System Dashboard</h1>
        <p className="text-gray-600">Monitor and control your digital persona laboratory</p>
      </div>

      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6 mb-8">
        <Card>
          <CardHeader>
            <CardTitle>System Health</CardTitle>
            <CardDescription>Current system status</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="flex items-center space-x-2">
              <Badge variant={systemStatus?.status === 'healthy' ? 'default' : 'destructive'}>
                {systemStatus?.status || 'Unknown'}
              </Badge>
            </div>
          </CardContent>
        </Card>

        <Card>
          <CardHeader>
            <CardTitle>Active Personas</CardTitle>
            <CardDescription>Managed digital personas</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">1</div>
            <p className="text-sm text-gray-600">Chris Bot - Active</p>
          </CardContent>
        </Card>

        <Card>
          <CardHeader>
            <CardTitle>Knowledge Graph</CardTitle>
            <CardDescription>Nodes and relationships</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="text-2xl font-bold">2,847</div>
            <p className="text-sm text-gray-600">Nodes | 5,231 Edges</p>
          </CardContent>
        </Card>
      </div>

      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
        <Card>
          <CardHeader>
            <CardTitle>Recent Activity</CardTitle>
            <CardDescription>Latest system events</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="space-y-4">
              {recentActivity.map((activity, index) => (
                <div key={index} className="flex items-center space-x-3">
                  <div className="w-2 h-2 bg-blue-500 rounded-full"></div>
                  <div className="flex-1">
                    <p className="text-sm">{activity.description}</p>
                    <p className="text-xs text-gray-500">{activity.timestamp}</p>
                  </div>
                </div>
              ))}
            </div>
          </CardContent>
        </Card>

        <Card>
          <CardHeader>
            <CardTitle>Quick Actions</CardTitle>
            <CardDescription>Common operations</CardDescription>
          </CardHeader>
          <CardContent>
            <div className="space-y-3">
              <Button className="w-full justify-start">
                Start Knowledge Ingestion
              </Button>
              <Button variant="outline" className="w-full justify-start">
                Create New Persona
              </Button>
              <Button variant="outline" className="w-full justify-start">
                View Graph Explorer
              </Button>
              <Button variant="outline" className="w-full justify-start">
                Open Chat Interface
              </Button>
            </div>
          </CardContent>
        </Card>
      </div>
    </div>
  )
}

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Start Ollama service
ollama serve &

# Pull required models
ollama pull llama3.2:3b
ollama pull mistral:7b
ollama pull gemma2:9b

# Verify installation
ollama list

# Clone ComfyUI repository
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Install dependencies
pip install -r requirements.txt

# Download Stable Diffusion models (you'll need to obtain these legally)
# Place models in models/checkpoints/

# Start ComfyUI
python main.py --listen 0.0.0.0 --port 8188

# Install Coqui TTS
pip install coqui-tts

# Download voice models
tts --model_name tts_models/en/ljspeech/tacotron2-DDC_ph --text "Hello world" --out_path test.wav

# List available models
tts --list_models

FROM python:3.11-slim

# Install system dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    cmake \
    git \
    libssl-dev \
    libffi-dev \
    postgresql-client \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Create non-root user
RUN useradd --create-home --shell /bin/bash app

# Install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY --chown=app:app . /app
USER app
WORKDIR /app

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
    CMD python -c "import requests; requests.get('http://localhost:8000/health')"

EXPOSE 8000

CMD ["uvicorn", "src.api.app:app", "--host", "0.0.0.0", "--port", "8000"]

FROM node:20-alpine

# Install dependencies only when needed
FROM base AS deps
RUN apk add --no-cache libc6-compat
WORKDIR /app

COPY package.json package-lock.json ./
RUN npm ci --only=production

FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .

ENV NEXT_TELEMETRY_DISABLED 1
RUN npm run build

FROM base AS runner
WORKDIR /app

ENV NODE_ENV production
ENV NEXT_TELEMETRY_DISABLED 1

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000
ENV PORT 3000

CMD ["node", "server.js"]

version: '3.8'
services:
  backend:
    build: ./backend
    ports:
      - "8000:8000"
    volumes:
      - ./backend:/app
      - ./models:/app/models
      - ./data:/app/data
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/simulacra
      - NEO4J_URI=bolt://neo4j:7687
      - CHROMA_HOST=chroma
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
    depends_on:
      - db
      - neo4j
      - chroma
      - redis

  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    environment:
      - NEXT_PUBLIC_API_URL=http://localhost:8000/api
    depends_on:
      - backend

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: simulacra
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - postgres_data:/var/lib/postgresql/data

  neo4j:
    image: neo4j:5.17
    environment:
      NEO4J_AUTH: neo4j/password
    ports:
      - "7474:7474"
      - "7687:7687"
    volumes:
      - neo4j_data:/data

  chroma:
    image: chromadb/chroma:latest
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  neo4j_data:
  chroma_data:
  redis_data:

# Database Configuration
DATABASE_URL=postgresql://user:password@localhost:5432/simulacra
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=password

# Vector Database
CHROMA_HOST=localhost
CHROMA_PORT=8000

# LLM Configuration
OLLAMA_BASE_URL=http://localhost:11434
DEFAULT_MODEL=llama3.2:3b
MAX_TOKENS=4096
TEMPERATURE=0.7

# Security
SECRET_KEY=your-secret-key-here
ENCRYPTION_KEY=your-32-byte-encryption-key
JWT_SECRET_KEY=your-jwt-secret
JWT_ALGORITHM=HS256
JWT_ACCESS_TOKEN_EXPIRE_MINUTES=30

# External APIs (Optional)
REDDIT_CLIENT_ID=your-client-id
REDDIT_CLIENT_SECRET=your-client-secret
OPENAI_API_KEY=your-openai-key

# File Storage
UPLOAD_DIR=/app/uploads
AUDIO_CACHE_DIR=/app/audio_cache
MODEL_CACHE_DIR=/app/models

# Performance Tuning
MAX_WORKERS=4
REQUEST_TIMEOUT=30
RATE_LIMIT_REQUESTS=100
RATE_LIMIT_WINDOW=60

# Logging
LOG_LEVEL=INFO
LOG_FORMAT=json

NEXT_PUBLIC_API_URL=http://localhost:8000/api
NEXT_PUBLIC_WS_URL=ws://localhost:8000/ws
NEXT_PUBLIC_APP_NAME=Simulacra System
NEXT_PUBLIC_VERSION=1.0.0
NEXT_PUBLIC_ENVIRONMENT=development

# Analytics (Optional)
NEXT_PUBLIC_ANALYTICS_ID=your-analytics-id
NEXT_PUBLIC_SENTRY_DSN=your-sentry-dsn

# Feature Flags
NEXT_PUBLIC_ENABLE_VOICE=true
NEXT_PUBLIC_ENABLE_MULTIMODAL=true
NEXT_PUBLIC_ENABLE_COLLABORATION=false

# Install testing dependencies
pip install pytest pytest-asyncio pytest-cov httpx

# Create test structure
mkdir -p backend/tests/{unit,integration,e2e}
mkdir -p backend/tests/unit/{api,agents,persona}

# Install testing dependencies
npm install --save-dev jest @testing-library/react @testing-library/jest-dom @testing-library/user-event jest-environment-jsdom

# Configure Jest
# jest.config.js
export default {
  testEnvironment: 'jsdom',
  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
  moduleNameMapping: {
    '^@/(.*)$': '<rootDir>/src/$1',
  },
}

# Build all services
docker-compose build

# Start the system
docker-compose up -d

# Check logs
docker-compose logs -f

# Verify services are running
curl http://localhost:8000/health
curl http://localhost:3000

# /etc/nginx/sites-available/simulacra
server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }

    location /api/ {
        proxy_pass http://localhost:8000/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

# backend/scripts/import_personal_data.py
import os
from pathlib import Path
from src.ingestion.pipeline import KnowledgeIngestionPipeline
from src.persona.extraction.trait_extractor import TraitExtractor

def import_chris_data():
    """Import Chris's personal data for persona creation"""

    # Initialize components
    ingestion_pipeline = KnowledgeIngestionPipeline()
    trait_extractor = TraitExtractor()

    # Define data sources
    data_sources = [
        "/path/to/chris/journals/",
        "/path/to/chris/emails/",
        "/path/to/chris/documents/",
    ]

    all_texts = []

    # Process each data source
    for source_path in data_sources:
        if os.path.exists(source_path):
            for file_path in Path(source_path).rglob("*"):
                if file_path.suffix in ['.txt', '.md', '.docx']:
                    try:
                        with open(file_path, 'r', encoding='utf-8') as f:
                            content = f.read()
                            all_texts.append(content)

                            # Process through ingestion pipeline
                            doc = {
                                'content': content,
                                'source': str(file_path),
                                'type': 'personal_document'
                            }
                            processed_docs = ingestion_pipeline.process_documents([doc])

                            # Store in knowledge graph
                            # ... implementation ...

                    except Exception as e:
                        print(f"Error processing {file_path}: {e}")

    # Extract personality traits
    if all_texts:
        traits = trait_extractor.extract_traits(all_texts)

        # Create Chris persona
        chris_persona = {
            'id': 'chris_bot_v1',
            'name': 'Chris Bot',
            'traits': traits,
            'training_data_count': len(all_texts),
            'created_at': datetime.now().isoformat()
        }

        # Save persona configuration
        # ... implementation ...

        print(f"Chris Bot persona created with {len(all_texts)} training samples")
        print(f"Extracted traits: {traits}")

if __name__ == "__main__":
    import_chris_data()

# Navigate to project root
cd simulacra-system

# Start all services
docker-compose up -d

# Check that services are running
docker-compose ps

# View logs
docker-compose logs -f backend

# Check Python dependencies
cd backend
source venv/bin/activate
pip install -r requirements.txt

# Verify database connections
python -c "import psycopg2; psycopg2.connect('postgresql://user:password@localhost:5432/simulacra')"
python -c "from neo4j import GraphDatabase; GraphDatabase.driver('bolt://localhost:7687', auth=('neo4j', 'password'))"

# Clear Next.js cache
cd frontend
rm -rf .next node_modules
npm install
npm run build

# Restart databases
docker-compose restart db neo4j chroma

# Check database logs
docker-compose logs db
docker-compose logs neo4j

# Monitor resource usage
docker stats

# Check Ollama GPU usage
nvidia-smi

# Optimize Docker resource limits
# Edit docker-compose.yml to add resource constraints