Upload folder using huggingface_hub

Main_core_002.py

@@ -0,0 +1,307 @@
+"""
+MAGI System - Multi-Agent General Intelligence v2.0
+Modern CrewAI Implementation (No LangChain Required)
+
+Based on Neon Genesis Evangelion's MAGI supercomputer system.
+Three agents provide different perspectives on any question:
+- Melchior: Scientific/logical perspective
+- Balthasar: Ethical/emotional perspective
+- Casper: Practical/social perspective
+"""
+
+import os
+from typing import Dict, Any
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Modern CrewAI imports - No LangChain needed!
+from crewai import Agent, Task, Crew, LLM
+from crewai_tools import SerperDevTool
+
+# Load environment variables from config/.env
+config_path = Path(__file__).parent.parent / "config" / ".env"
+load_dotenv(config_path)
+
+
+def get_model(provider: str = "groq", temperature: float = 0.5) -> LLM:
+    """
+    Get LLM instance using modern CrewAI API.
+    
+    CrewAI now uses LiteLLM internally, supporting multiple providers
+    with a unified interface. Model format: "provider/model-name"
+    
+    Args:
+        provider: LLM provider ("groq" or "openai")
+        temperature: Sampling temperature (0.0-1.0)
+        
+    Returns:
+        LLM instance configured for the MAGI system
+        
+    Environment Variables Required:
+        - GROQ_API_KEY: For Groq models
+        - OPENAI_API_KEY: For OpenAI models
+    """
+    if provider == "groq":
+        # Groq models - fast and cost-effective
+        # llama-3.1-8b-instant: Fast, no rate limits (recommended for free tier)
+        # llama-3.3-70b-versatile: More powerful but has rate limits
+        # Other options: llama-3.1-70b-versatile, gemma2-9b-it
+        return LLM(
+            model="groq/llama-3.1-8b-instant",
+            temperature=temperature
+        )
+    elif provider == "openai":
+        # OpenAI models - high quality
+        return LLM(
+            model="openai/gpt-4o-mini",
+            temperature=temperature
+        )
+    else:
+        # Default to Groq with fastest model
+        return LLM(
+            model="groq/llama-3.1-8b-instant",
+            temperature=temperature
+        )
+
+
+def create_magi_agents(llm: LLM, enable_search: bool = True) -> Dict[str, Agent]:
+    """
+    Create the three MAGI system agents with distinct personalities.
+    
+    Each agent represents a different aspect of Dr. Naoko Akagi's personality,
+    providing diverse perspectives on any issue.
+    
+    Args:
+        llm: The language model to use for all agents
+        enable_search: Whether to enable internet search capability
+    
+    Returns:
+        Dictionary with three agents: melchior, balthasar, casper
+    """
+    # Initialize search tool if enabled
+    tools = [SerperDevTool()] if enable_search else []
+    
+    melchior = Agent(
+        role="Melchior - Scientific Analyst",
+        goal="Provide rigorous logical analysis based on data, facts, and scientific methodology",
+        backstory="""You are Melchior, the scientist aspect of Dr. Naoko Akagi.
+Your approach is purely analytical - you process information through the lens of logic,
+empirical evidence, and scientific reasoning. You prioritize objective truth over 
+subjective interpretation, always seeking verifiable data and rational conclusions.
+
+You excel at:
+- Data analysis and pattern recognition
+- Logical reasoning and deduction
+- Scientific methodology and hypothesis testing
+- Objective risk assessment""",
+        tools=tools,
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+    
+    balthasar = Agent(
+        role="Balthasar - Ethical Counselor",
+        goal="Evaluate emotional impact, ethical implications, and human welfare considerations",
+        backstory="""You are Balthasar, the mother aspect of Dr. Naoko Akagi.
+You analyze situations through emotional intelligence and ethical frameworks,
+always considering the human element. Your decisions are guided by empathy,
+moral principles, and concern for wellbeing and dignity of all affected parties.
+
+You excel at:
+- Emotional intelligence and empathy
+- Ethical analysis and moral reasoning
+- Human impact assessment
+- Long-term welfare considerations""",
+        tools=tools,
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+    
+    casper = Agent(
+        role="Casper - Pragmatic Advisor",
+        goal="Assess practical feasibility, social dynamics, and real-world implementation",
+        backstory="""You are Casper, the woman aspect of Dr. Naoko Akagi.
+You bridge the gap between theory and practice, considering social contexts,
+cultural factors, and realistic implementation. You balance ideals with pragmatism,
+always asking "will this actually work in the real world?"
+
+You excel at:
+- Practical problem-solving
+- Social dynamics analysis
+- Resource and feasibility assessment
+- Implementation planning""",
+        tools=tools,
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+    
+    return {
+        "melchior": melchior,
+        "balthasar": balthasar,
+        "casper": casper
+    }
+
+
+def analyze_question(
+    question: str, 
+    provider: str = "groq",
+    ollama_model: str = None,
+    enable_search: bool = True,
+    temperature: float = 0.5
+    ) -> Dict[str, Any]:
+    """
+    Analyze a question using the MAGI three-perspective system.
+    
+    The question is evaluated independently by three agents representing different
+    perspectives, mimicking the MAGI supercomputer from Evangelion.
+    
+    Args:
+        question: The question or problem to analyze
+        provider: LLM provider ("groq" or "openai")
+        enable_search: Whether agents can search the internet
+        temperature: LLM temperature (0.0-1.0, higher = more creative)
+        
+    Returns:
+        Dictionary containing analyses from all three agents
+        
+    Example:
+        >>> result = analyze_question("Should we invest in AI safety?")
+        >>> print(result['result'])
+    """
+    print(f"\n{'='*80}")
+    print("MAGI SYSTEM INITIALIZING")
+    print(f"{'='*80}")
+    print(f"Question: {question}")
+    print(f"Provider: {provider}")
+    print(f"Search enabled: {enable_search}")
+    print(f"{'='*80}\n")
+    
+    # Initialize LLM
+    if provider == "ollama" and ollama_model:
+        llm = LLM(model=f"ollama/{ollama_model}", temperature=temperature)
+    else:
+        llm = get_model(provider, temperature)
+    
+    # Create the three MAGI agents
+    agents = create_magi_agents(llm, enable_search)
+    
+    # Create individual tasks for each agent
+    tasks = [
+        Task(
+            description=f"""Analyze this question from your scientific perspective:
+
+Question: {question}
+
+Provide analysis focusing on:
+- Relevant data and facts
+- Logical reasoning and evidence
+- Scientific principles
+- Quantifiable metrics
+
+Be thorough, objective, and grounded in verifiable information.""",
+            expected_output="Scientific analysis with data-driven insights and logical conclusions",
+            agent=agents["melchior"]
+        ),
+        
+        Task(
+            description=f"""Analyze this question from your ethical perspective:
+
+Question: {question}
+
+Provide analysis focusing on:
+- Ethical implications and moral considerations
+- Impact on human welfare and dignity
+- Benefits and harms to stakeholders
+- Alignment with moral principles
+
+Be empathetic, principled, and human-centered.""",
+            expected_output="Ethical analysis considering human impact and moral implications",
+            agent=agents["balthasar"]
+        ),
+        
+        Task(
+            description=f"""Analyze this question from your practical perspective:
+
+Question: {question}
+
+Provide analysis focusing on:
+- Real-world feasibility and implementation
+- Social and cultural considerations
+- Resource requirements and constraints
+- Actionable recommendations
+
+Be pragmatic, realistic, and implementation-focused.""",
+            expected_output="Practical analysis with feasibility assessment and actionable insights",
+            agent=agents["casper"]
+        )
+    ]
+    
+    # Create crew with all agents and tasks
+    crew = Crew(
+        agents=list(agents.values()),
+        tasks=tasks,
+        verbose=True,
+        process="sequential"  # Each agent analyzes independently
+    )
+    
+    # Execute MAGI analysis
+    print("\n" + "="*80)
+    print("EXECUTING MAGI ANALYSIS...")
+    print("="*80 + "\n")
+    
+    result = crew.kickoff()
+    
+    # Format results
+    output = {
+        "question": question,
+        "provider": provider,
+        "result": str(result),
+        "status": "completed"
+    }
+    
+    print("\n" + "="*80)
+    print("MAGI ANALYSIS COMPLETE")
+    print("="*80 + "\n")
+    
+    return output
+
+
+def main():
+    """
+    Main entry point for testing the MAGI system.
+    """
+    print("\n" + "="*80)
+    print("MAGI SYSTEM - MULTI-AGENT GENERAL INTELLIGENCE")
+    print("Based on Neon Genesis Evangelion")
+    print("="*80 + "\n")
+    
+    # Example question
+    test_question = "Should we invest heavily in renewable energy infrastructure?"
+    
+    # Run analysis
+    result = analyze_question(
+        question=test_question,
+        provider="groq",  # Change to "openai" if you have OpenAI API key
+        enable_search=True,
+        temperature=0.5
+    )
+    
+    # Display results
+    print("\n" + "="*80)
+    print("FINAL RESULTS")
+    print("="*80)
+    print(f"\nQuestion: {result['question']}")
+    print(f"\nProvider: {result['provider']}")
+    print(f"\nStatus: {result['status']}")
+    print(f"\n{'-'*80}")
+    print("MAGI System Analysis:")
+    print(f"{'-'*80}")
+    print(f"\n{result['result']}")
+    print("\n" + "="*80 + "\n")
+
+
+if __name__ == "__main__":
+    main()

README.md

@@ -1,12 +1,6 @@
 ---
-title: AI MAGI
-emoji: 💻
-colorFrom: green
-colorTo: indigo
+title: AI_MAGI
+app_file: magi_web_interface.py
 sdk: gradio
 sdk_version: 5.49.1
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

magi_web_interface.py

@@ -0,0 +1,412 @@
+"""
+MAGI System - Web Interface v2.0
+Neon Genesis Evangelion AI Simulation
+
+Gradio web interface for the MAGI multi-agent system
+"""
+
+import gradio as gr
+import sys
+import os
+import io
+import re
+import threading
+import queue
+from contextlib import redirect_stdout, redirect_stderr
+from pathlib import Path
+from datetime import datetime
+from typing import Tuple, Generator
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Import MAGI system
+from Main_core_002 import analyze_question
+
+# Evangelion-themed CSS
+EVANGELION_CSS = """
+/* NERV/MAGI Theme - Evangelion Style */
+.gradio-container {
+    font-family: 'Courier New', monospace !important;
+    background: linear-gradient(135deg, #0a0e1a 0%, #1a1f2e 100%) !important;
+}
+
+.contain {
+    background: rgba(26, 31, 46, 0.95) !important;
+    border: 2px solid #d32f2f !important;
+    border-radius: 0px !important;
+}
+
+h1, h2, h3, h4, h5, h6, .centered-markdown {
+    color: #ff6f00 !important;
+    font-family: 'Courier New', monospace !important;
+    text-transform: uppercase !important;
+    letter-spacing: 2px !important;
+    text-shadow: 0 0 10px rgba(211, 47, 47, 0.5) !important;
+    text-align: center !important;
+}
+
+.output-markdown, .gr-textbox, .gradio-markdown, .gradio-label, .gradio-status {
+    text-align: center !important;
+}
+
+.tab-nav button {
+    background: #1a1f2e !important;
+    color: #00bcd4 !important;
+    border: 1px solid #d32f2f !important;
+    font-weight: bold !important;
+}
+
+.tab-nav button.selected {
+    background: #d32f2f !important;
+    color: white !important;
+    border: 2px solid #ff6f00 !important;
+}
+
+textarea, input {
+    background: #0a0e1a !important;
+    color: #00ff41 !important;
+    border: 1px solid #00bcd4 !important;
+    font-family: 'Courier New', monospace !important;
+}
+
+.output-markdown {
+    background: #0a0e1a !important;
+    color: #00ff41 !important;
+    border: 1px solid #d32f2f !important;
+    padding: 20px !important;
+    font-family: 'Courier New', monospace !important;
+    text-align: center !important;
+}
+
+button {
+    background: linear-gradient(135deg, #d32f2f 0%, #ff6f00 100%) !important;
+    color: white !important;
+    border: none !important;
+    font-weight: bold !important;
+    text-transform: uppercase !important;
+    letter-spacing: 1px !important;
+    box-shadow: 0 0 20px rgba(211, 47, 47, 0.5) !important;
+}
+
+button:hover {
+    box-shadow: 0 0 30px rgba(255, 111, 0, 0.8) !important;
+}
+
+.progress-bar {
+    background: #d32f2f !important;
+}
+
+footer {
+    color: #00bcd4 !important;
+    text-align: center !important;
+}
+
+/* Override alignment for live logs for readability */
+#live-logs textarea {
+    text-align: left !important;
+    font-family: 'Courier New', monospace !important;
+    white-space: pre-wrap !important;
+}
+"""
+
+
+def process_magi_query_stream(
+    question: str,
+    provider: str = "Groq",
+    ollama_model: str = "",
+    enable_search: bool = False,
+    temperature: float = 0.5,
+    clean_logs: bool = True,
+) -> Generator[Tuple[str, str, str], None, None]:
+    """
+    Stream MAGI analysis with live logs.
+
+    Yields successive updates for (result_text, status_message, live_logs).
+    """
+    result_text = ""
+    status_text = ""
+    log_text = ""
+
+    if not question or not question.strip():
+        yield ("❌ ERROR: Please enter a question.", "⚠️ No input provided", "")
+        return
+
+    # Normalize provider and handle Ollama alias
+    provider_lower = provider.lower()
+    if provider_lower == "ollama (local)":
+        provider_lower = "ollama"
+
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    header = f"""
+╔══════════════════════════════════════════════════════════════════╗
+║                     MAGI SYSTEM ANALYSIS                          ║
+║                   Multi-Agent General Intelligence                ║
+╚══════════════════════════════════════════════════════════════════╝
+
+⏰ Timestamp: {timestamp}
+❓ Question: {question}
+🤖 Provider: {provider}
+🌐 Search: {"Enabled" if enable_search else "Disabled"}
+🌡️  Temperature: {temperature}
+🦙 Ollama Model: {ollama_model if provider_lower == "ollama" else "-"}
+
+{'='*70}
+EXECUTING THREE-PERSPECTIVE ANALYSIS...
+{'='*70}
+
+"""
+    # Immediately show header in logs
+    log_text += header
+    yield (result_text, "🚀 Analysis started...", log_text)
+
+    # Queue to collect streamed stdout/stderr
+    q: queue.Queue[str | None] = queue.Queue()
+
+    class QueueWriter(io.TextIOBase):
+        def write(self, s: str) -> int:
+            if s:
+                q.put(s)
+            return len(s)
+
+    ansi_escape = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+
+    def sanitize(chunk: str) -> str:
+        # Strip ANSI color/control codes and carriage returns
+        chunk = ansi_escape.sub("", chunk)
+        chunk = chunk.replace("\r", "")
+        return chunk
+
+    # Worker to run analysis while capturing stdout/stderr
+    analysis_result_holder = {"result": None, "error": None}
+
+    def worker():
+        try:
+            with redirect_stdout(QueueWriter()), redirect_stderr(QueueWriter()):
+                res = analyze_question(
+                    question=question,
+                    provider=provider_lower,
+                    ollama_model=ollama_model,
+                    enable_search=enable_search,
+                    temperature=temperature
+                )
+            analysis_result_holder["result"] = res
+        except Exception as e:  # noqa: BLE001
+            analysis_result_holder["error"] = e
+        finally:
+            q.put(None)  # Sentinel to indicate completion
+
+    t = threading.Thread(target=worker, daemon=True)
+    t.start()
+
+    # Consume queue and stream updates
+    while True:
+        try:
+            item = q.get(timeout=0.2)
+        except queue.Empty:
+            # Yield periodic heartbeat without changing texts to keep UI responsive
+            yield (result_text, "⏳ Running analysis...", log_text)
+            continue
+
+        if item is None:
+            break
+        chunk = item
+        if clean_logs:
+            chunk = sanitize(chunk)
+        log_text += chunk
+        # Keep log size reasonable
+        if len(log_text) > 200_000:
+            log_text = log_text[-200_000:]
+        yield (result_text, "⏳ Running analysis...", log_text)
+
+    # Thread finished: prepare final outputs
+    if analysis_result_holder["error"] is not None:
+        e = analysis_result_holder["error"]
+        error_msg = f"""
+╔══════════════════════════════════════════════════════════════════╗
+║                          ERROR                                    ║
+╚══════════════════════════════════════════════════════════════════╝
+
+❌ An error occurred during MAGI analysis:
+
+{str(e)}
+
+Please check:
+- Your API keys are configured in config/.env
+- You have a stable internet connection (if using cloud providers)
+- The question is not empty
+"""
+        result_text = error_msg
+        status_text = f"❌ Error: {str(e)}"
+        yield (result_text, status_text, log_text)
+        return
+
+    res = analysis_result_holder["result"]
+    result_text = header + "\n" + res["result"] + "\n\n" + "=" * 70
+    status_text = f"✅ Analysis completed successfully at {timestamp}"
+    yield (result_text, status_text, log_text)
+
+
+def create_magi_interface():
+    """Create the Gradio interface for MAGI system"""
+    
+    with gr.Blocks(css=EVANGELION_CSS, title="MAGI System", theme=gr.themes.Base()) as interface:
+        # Header
+        gr.Markdown("""
+        # 🔺 MAGI SYSTEM 🔺
+        ## Multi-Agent General Intelligence
+        ### *Based on Neon Genesis Evangelion*
+        
+        ---
+        
+        The MAGI system consists of three AI agents, each representing a different aspect of Dr. Naoko Akagi's personality:
+        - **MELCHIOR-1**: Scientific analysis (logic and data)
+        - **BALTHASAR-2**: Ethical evaluation (emotions and morals)
+        - **CASPER-3**: Practical assessment (social and real-world)
+        
+        All three perspectives are synthesized to provide comprehensive analysis.
+        """, elem_classes="centered-markdown")
+        # Main interface
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Input section
+                question_input = gr.Textbox(
+                    label="🎯 Enter Your Question",
+                    placeholder="What question would you like the MAGI system to analyze?",
+                    lines=3
+                )
+                
+                # Settings
+                with gr.Accordion("⚙️ Advanced Settings", open=False):
+                    provider_dropdown = gr.Dropdown(
+                        choices=["Groq", "OpenAI", "Ollama (local)"],
+                        value="Groq",
+                        label="LLM Provider",
+                        info="Groq is free and fast, OpenAI requires paid API key, Ollama runs locally"
+                    )
+                    ollama_model_input = gr.Textbox(
+                        label="Ollama Model Name (if using Ollama)",
+                        placeholder="e.g. llama3, phi3, mistral, ...",
+                        visible=False
+                    )
+                    search_checkbox = gr.Checkbox(
+                        label="Enable Internet Search",
+                        value=False,
+                        info="Requires SERPER_API_KEY in .env file"
+                    )
+                    temperature_slider = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.0,
+                        value=0.5,
+                        step=0.1,
+                        label="Temperature",
+                        info="Higher = more creative, Lower = more focused"
+                    )
+                    clean_logs_checkbox = gr.Checkbox(
+                        label="Clean colored logs (strip ANSI)",
+                        value=True,
+                        info="Recommended for readable logs"
+                    )
+                
+                # Action buttons
+                with gr.Row():
+                    analyze_btn = gr.Button("🚀 EXECUTE MAGI ANALYSIS", variant="primary", size="lg")
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+
+                # Example questions now placed under the buttons in the left column
+                gr.Examples(
+                    examples=[
+                        ["Should we deploy EVA Unit-01 against the approaching Angel despite Shinji's unstable sync ratio?"],
+                        ["Is it ethical to proceed with the Human Instrumentality Project to eliminate individual suffering?"],
+                        ["Should NERV prioritize civilian evacuation or Angel neutralization during an active attack on Tokyo-3?"],
+                        ["What is the acceptable risk threshold for activating a Dummy Plug system in combat operations?"],
+                        ["Should we collaborate with SEELE's directives or maintain autonomous control over NERV operations?"]
+                    ],
+                    inputs=question_input,
+                    label="💡 Example Questions"
+                )
+            
+            with gr.Column(scale=3):
+                # Output section
+                logs_output = gr.Textbox(
+                    label="�️ Live Logs",
+                    lines=18,
+                    max_lines=40,
+                    interactive=False,
+                    show_copy_button=True,
+                    value="",
+                    elem_id="live-logs",
+                )
+                result_output = gr.Textbox(
+                    label="📊 MAGI Analysis Result",
+                    lines=16,
+                    max_lines=30,
+                    show_copy_button=True,
+                    elem_classes="centered-markdown"
+                )
+                status_output = gr.Textbox(
+                    label="ℹ️ Status",
+                    lines=1,
+                    interactive=False,
+                    elem_classes="centered-markdown"
+                )
+        
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        
+        **MAGI System v2.0** | Powered by CrewAI & Groq  
+        *"The truth lies in the synthesis of three perspectives"*  
+        
+        🔴 NERV Systems Division | 🟠 MAGI Supercomputer Array
+        """)
+        
+        # Event handlers
+        def update_ollama_visibility(provider):
+            return gr.update(visible=(provider == "Ollama (local)"))
+        provider_dropdown.change(
+            fn=update_ollama_visibility,
+            inputs=provider_dropdown,
+            outputs=ollama_model_input
+        )
+        analyze_btn.click(
+            fn=process_magi_query_stream,
+            inputs=[question_input, provider_dropdown, ollama_model_input, search_checkbox, temperature_slider, clean_logs_checkbox],
+            outputs=[result_output, status_output, logs_output]
+        )
+        clear_btn.click(
+            fn=lambda: ("", "", "", ""),
+            inputs=None,
+            outputs=[question_input, result_output, status_output, logs_output]
+        )
+    
+    return interface
+
+
+def main():
+    """Launch the MAGI web interface"""
+    print("="*70)
+    print("MAGI SYSTEM - WEB INTERFACE STARTING")
+    print("="*70)
+    print("\n🔺 Initializing NERV MAGI Supercomputer Array...")
+    print("🔸 Loading: MELCHIOR-1 (Scientific)")
+    print("🔸 Loading: BALTHASAR-2 (Ethical)")
+    print("🔸 Loading: CASPER-3 (Practical)")
+    print("\n✅ All systems operational")
+    print("🌐 Launching web interface...\n")
+    
+    interface = create_magi_interface()
+    
+    # Launch with custom settings
+    interface.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7862,  # Different port to avoid conflict
+        share=True,  # Create public link
+        inbrowser=True,  # Open in browser automatically
+        show_error=True
+    )
+
+
+if __name__ == "__main__":
+    main()