""" LLM Integration for HAIM Multi-provider LLM support: OpenAI, OpenRouter, Anthropic, Google Gemini, and Local AI models """ import json import os from datetime import datetime from typing import List, Dict, Optional, Tuple, Any, Callable from dataclasses import dataclass, field from enum import Enum from loguru import logger from mnemocore.core.engine import HAIMEngine from mnemocore.core.node import MemoryNode from mnemocore.core.exceptions import ( UnsupportedProviderError, AgentNotFoundError, ) class LLMProvider(Enum): """Supported LLM providers""" OPENAI = "openai" OPENROUTER = "openrouter" ANTHROPIC = "anthropic" GOOGLE_GEMINI = "google_gemini" OLLAMA = "ollama" LM_STUDIO = "lm_studio" CUSTOM = "custom" MOCK = "mock" @dataclass class LLMConfig: """Configuration for LLM provider""" provider: LLMProvider = LLMProvider.MOCK model: str = "gpt-4" api_key: Optional[str] = None base_url: Optional[str] = None max_tokens: int = 1024 temperature: float = 0.7 extra_headers: Dict[str, str] = field(default_factory=dict) extra_params: Dict[str, Any] = field(default_factory=dict) # Provider-specific defaults @classmethod def openai(cls, model: str = "gpt-4", api_key: Optional[str] = None, **kwargs) -> 'LLMConfig': return cls(provider=LLMProvider.OPENAI, model=model, api_key=api_key, **kwargs) @classmethod def openrouter(cls, model: str = "anthropic/claude-3.5-sonnet", api_key: Optional[str] = None, **kwargs) -> 'LLMConfig': return cls( provider=LLMProvider.OPENROUTER, model=model, api_key=api_key, base_url="https://openrouter.ai/api/v1", extra_headers={"HTTP-Referer": "https://mnemocore.ai", "X-Title": "MnemoCore"}, **kwargs ) @classmethod def anthropic(cls, model: str = "claude-3-5-sonnet-20241022", api_key: Optional[str] = None, **kwargs) -> 'LLMConfig': return cls(provider=LLMProvider.ANTHROPIC, model=model, api_key=api_key, **kwargs) @classmethod def google_gemini(cls, model: str = "gemini-1.5-pro", api_key: Optional[str] = None, **kwargs) -> 'LLMConfig': return cls(provider=LLMProvider.GOOGLE_GEMINI, model=model, api_key=api_key, **kwargs) @classmethod def ollama(cls, model: str = "llama3.1", base_url: str = "http://localhost:11434", **kwargs) -> 'LLMConfig': return cls(provider=LLMProvider.OLLAMA, model=model, base_url=base_url, **kwargs) @classmethod def lm_studio(cls, model: str = "local-model", base_url: str = "http://localhost:1234/v1", **kwargs) -> 'LLMConfig': return cls(provider=LLMProvider.LM_STUDIO, model=model, base_url=base_url, **kwargs) @classmethod def custom(cls, model: str, base_url: str, api_key: Optional[str] = None, **kwargs) -> 'LLMConfig': return cls(provider=LLMProvider.CUSTOM, model=model, base_url=base_url, api_key=api_key, **kwargs) @classmethod def mock(cls, **kwargs) -> 'LLMConfig': return cls(provider=LLMProvider.MOCK, **kwargs) class LLMClientFactory: """Factory for creating LLM clients""" @staticmethod def create_client(config: LLMConfig) -> Any: """Create an LLM client based on configuration""" provider = config.provider if provider == LLMProvider.MOCK: return None if provider == LLMProvider.OPENAI: return LLMClientFactory._create_openai_client(config) if provider == LLMProvider.OPENROUTER: return LLMClientFactory._create_openrouter_client(config) if provider == LLMProvider.ANTHROPIC: return LLMClientFactory._create_anthropic_client(config) if provider == LLMProvider.GOOGLE_GEMINI: return LLMClientFactory._create_gemini_client(config) if provider == LLMProvider.OLLAMA: return LLMClientFactory._create_ollama_client(config) if provider == LLMProvider.LM_STUDIO: return LLMClientFactory._create_lm_studio_client(config) if provider == LLMProvider.CUSTOM: return LLMClientFactory._create_custom_client(config) supported = [p.value for p in LLMProvider] raise UnsupportedProviderError(str(provider.value), supported_providers=supported) @staticmethod def _create_openai_client(config: LLMConfig) -> Any: """Create OpenAI client""" try: from openai import OpenAI api_key = config.api_key or os.environ.get("OPENAI_API_KEY") return OpenAI(api_key=api_key) except ImportError: logger.warning("openai package not installed. Install with: pip install openai") return None @staticmethod def _create_openrouter_client(config: LLMConfig) -> Any: """Create OpenRouter client (OpenAI-compatible)""" try: from openai import OpenAI api_key = config.api_key or os.environ.get("OPENROUTER_API_KEY") return OpenAI( base_url=config.base_url, api_key=api_key, default_headers=config.extra_headers ) except ImportError: logger.warning("openai package not installed. Install with: pip install openai") return None @staticmethod def _create_anthropic_client(config: LLMConfig) -> Any: """Create Anthropic client""" try: import anthropic api_key = config.api_key or os.environ.get("ANTHROPIC_API_KEY") return anthropic.Anthropic(api_key=api_key) except ImportError: logger.warning("anthropic package not installed. Install with: pip install anthropic") return None @staticmethod def _create_gemini_client(config: LLMConfig) -> Any: """Create Google Gemini client""" try: import google.generativeai as genai api_key = config.api_key or os.environ.get("GOOGLE_API_KEY") genai.configure(api_key=api_key) return genai.GenerativeModel(config.model) except ImportError: logger.warning("google-generativeai package not installed. Install with: pip install google-generativeai") return None @staticmethod def _create_ollama_client(config: LLMConfig) -> Any: """Create Ollama client for local models""" try: from openai import OpenAI return OpenAI(base_url=config.base_url, api_key="ollama") except ImportError: # Fallback to direct HTTP calls return OllamaClient(base_url=config.base_url, model=config.model) @staticmethod def _create_lm_studio_client(config: LLMConfig) -> Any: """Create LM Studio client (OpenAI-compatible)""" try: from openai import OpenAI return OpenAI(base_url=config.base_url, api_key="lm-studio") except ImportError: logger.warning("openai package not installed. Install with: pip install openai") return None @staticmethod def _create_custom_client(config: LLMConfig) -> Any: """Create custom OpenAI-compatible client""" try: from openai import OpenAI return OpenAI( base_url=config.base_url, api_key=config.api_key or "custom" ) except ImportError: logger.warning("openai package not installed. Install with: pip install openai") return None class OllamaClient: """Fallback Ollama client using direct HTTP calls""" def __init__(self, base_url: str = "http://localhost:11434", model: str = "llama3.1"): self.base_url = base_url.rstrip("/") self.model = model def generate(self, prompt: str, max_tokens: int = 1024) -> str: """Generate response using Ollama API""" import urllib.request import urllib.error url = f"{self.base_url}/api/generate" data = { "model": self.model, "prompt": prompt, "stream": False, "options": {"num_predict": max_tokens} } try: req = urllib.request.Request( url, data=json.dumps(data).encode("utf-8"), headers={"Content-Type": "application/json"} ) with urllib.request.urlopen(req, timeout=120) as response: result = json.loads(response.read().decode("utf-8")) return result.get("response", "") except urllib.error.URLError as e: return f"[Ollama Error: {str(e)}]" class HAIMLLMIntegrator: """Bridge between HAIM holographic memory and LLM reasoning""" def __init__( self, haim_engine: HAIMEngine, llm_client=None, llm_config: Optional[LLMConfig] = None ): self.haim = haim_engine # Support both legacy client and new config-based approach if llm_config: self.config = llm_config self.llm_client = llm_client or LLMClientFactory.create_client(llm_config) elif llm_client: self.llm_client = llm_client self.config = LLMConfig.mock() else: self.llm_client = None self.config = LLMConfig.mock() @classmethod def from_config(cls, haim_engine: HAIMEngine, config: LLMConfig) -> 'HAIMLLMIntegrator': """Create integrator from LLM configuration""" client = LLMClientFactory.create_client(config) return cls(haim_engine=haim_engine, llm_client=client, llm_config=config) def _call_llm(self, prompt: str, max_tokens: int = None) -> str: """ Call the LLM with the given prompt. Supports multiple providers: OpenAI, OpenRouter, Anthropic, Gemini, Ollama, LM Studio """ max_tokens = max_tokens or self.config.max_tokens if self.config.provider == LLMProvider.MOCK or self.llm_client is None: return self._mock_llm_response(prompt) try: provider = self.config.provider # OpenAI / OpenRouter / LM Studio (all use OpenAI SDK) if provider in (LLMProvider.OPENAI, LLMProvider.OPENROUTER, LLMProvider.LM_STUDIO, LLMProvider.CUSTOM): return self._call_openai_compatible(prompt, max_tokens) # Anthropic if provider == LLMProvider.ANTHROPIC: return self._call_anthropic(prompt, max_tokens) # Google Gemini if provider == LLMProvider.GOOGLE_GEMINI: return self._call_gemini(prompt, max_tokens) # Ollama if provider == LLMProvider.OLLAMA: return self._call_ollama(prompt, max_tokens) # Fallback: try to detect client type return self._call_generic(prompt, max_tokens) except Exception as e: logger.error(f"LLM call failed: {e}") return f"[LLM Error: {str(e)}]" def _call_openai_compatible(self, prompt: str, max_tokens: int) -> str: """Call OpenAI-compatible API (OpenAI, OpenRouter, LM Studio)""" response = self.llm_client.chat.completions.create( model=self.config.model, messages=[{"role": "user", "content": prompt}], max_tokens=max_tokens, temperature=self.config.temperature, **self.config.extra_params ) return response.choices[0].message.content def _call_anthropic(self, prompt: str, max_tokens: int) -> str: """Call Anthropic Claude API""" response = self.llm_client.messages.create( model=self.config.model, max_tokens=max_tokens, temperature=self.config.temperature, messages=[{"role": "user", "content": prompt}], **self.config.extra_params ) return response.content[0].text def _call_gemini(self, prompt: str, max_tokens: int) -> str: """Call Google Gemini API""" generation_config = { "max_output_tokens": max_tokens, "temperature": self.config.temperature, **self.config.extra_params } response = self.llm_client.generate_content( prompt, generation_config=generation_config ) return response.text def _call_ollama(self, prompt: str, max_tokens: int) -> str: """Call Ollama local model""" if hasattr(self.llm_client, 'generate'): # Using our fallback OllamaClient return self.llm_client.generate(prompt, max_tokens) else: # Using OpenAI SDK with Ollama return self._call_openai_compatible(prompt, max_tokens) def _call_generic(self, prompt: str, max_tokens: int) -> str: """Generic fallback that tries to detect and use the client""" client = self.llm_client # OpenAI-style if hasattr(client, 'chat') and hasattr(client.chat, 'completions'): return self._call_openai_compatible(prompt, max_tokens) # Anthropic-style if hasattr(client, 'messages') and hasattr(client.messages, 'create'): return self._call_anthropic(prompt, max_tokens) # Simple callable if callable(client): return client(prompt) # Generate method if hasattr(client, 'generate'): return client.generate(prompt, max_tokens=max_tokens) return self._mock_llm_response(prompt) def _mock_llm_response(self, prompt: str) -> str: """Generate a mock LLM response when no client is available.""" if "Reconstruct" in prompt or "reconstruct" in prompt: return "[MOCK RECONSTRUCTION] Based on the retrieved memory fragments, I can synthesize the following: The information appears to be related to the query context. However, please configure an LLM client for actual reconstructive reasoning." elif "Evaluate" in prompt or "hypothesis" in prompt.lower(): return "[MOCK EVALUATION] Based on memory analysis: Hypothesis 1 appears most supported (confidence: 70%). Please configure an LLM client for actual hypothesis evaluation." return "[MOCK RESPONSE] Please configure an LLM client for actual responses." def reconstructive_recall( self, cue: str, top_memories: int = 5, enable_reasoning: bool = True ) -> Dict: """ Reconstruct memory from partial cue Similar to human recall - you remember fragments, brain reconstructs whole """ # Query HAIM for related memories results = self.haim.query(cue, top_k=top_memories) # Extract memory content memory_fragments = [] for node_id, similarity in results: node = self.haim.tier_manager.get_memory(node_id) if node: memory_fragments.append({ "content": node.content, "metadata": node.metadata, "similarity": similarity }) if not enable_reasoning: return { "cue": cue, "fragments": memory_fragments, "reconstruction": "LLM reasoning disabled" } # Use LLM to reconstruct from fragments reconstruction_prompt = self._build_reconstruction_prompt( cue=cue, fragments=memory_fragments ) # Call LLM for reconstruction reconstruction = self._call_llm(reconstruction_prompt) return { "cue": cue, "fragments": memory_fragments, "reconstruction": reconstruction } def _build_reconstruction_prompt( self, cue: str, fragments: List[Dict] ) -> str: """Build prompt for LLM reconstructive recall""" prompt = f"""You are an AI with holographic memory. A user asks a question, and you have retrieved partial memory fragments from your holographic memory. User's Question: "{cue}" Memory Fragments (retrieved by holographic similarity): """ for i, frag in enumerate(fragments, 1): prompt += f"\nFragment {i} (similarity: {frag['similarity']:.3f}):\n{frag['content']}\n" prompt += """ Task: Reconstruct a complete, coherent answer from these fragments. - Combine fragments intelligently - Fill in gaps using reasoning - If fragments conflict, use highest-similarity fragment as primary - Maintain factual accuracy - Don't hallucinate information not supported by fragments Reconstruction:""" return prompt def multi_hypothesis_query( self, query: str, hypotheses: List[str] ) -> Dict: """ Query with multiple active hypotheses (superposition) Returns LLM evaluation of which hypothesis is most likely """ # Query memories using superposition of hypotheses results = self._superposition_query(query, hypotheses, top_k=10) # Extract relevant memories relevant_memories = [] for node_id, similarity in results: node = self.haim.tier_manager.get_memory(node_id) if node: relevant_memories.append({ "content": node.content, "similarity": similarity }) # Build evaluation prompt evaluation_prompt = self._build_hypothesis_evaluation_prompt( query=query, hypotheses=hypotheses, relevant_memories=relevant_memories ) # Call LLM for evaluation evaluation = self._call_llm(evaluation_prompt) return { "query": query, "hypotheses": hypotheses, "relevant_memories": relevant_memories, "evaluation": evaluation } def _superposition_query( self, query: str, hypotheses: List[str], top_k: int = 10 ) -> List[Tuple[str, float]]: """ Perform a superposition query by combining query and hypotheses. Uses HDV bundling to create a superposition vector for retrieval. """ # Encode each hypothesis and the main query query_vec = self.haim.encode_content(query) # Create superposition by bundling all hypothesis vectors with the query hypothesis_vectors = [self.haim.encode_content(h) for h in hypotheses] # Bundle all vectors together (superposition) from mnemocore.core.binary_hdv import majority_bundle all_vectors = [query_vec] + hypothesis_vectors superposition_vec = majority_bundle(all_vectors) # Query each hypothesis individually and merge results all_results: Dict[str, float] = {} # Primary query primary_results = self.haim.query(query, top_k=top_k) for node_id, sim in primary_results: all_results[node_id] = sim # Query each hypothesis and accumulate scores for hypothesis in hypotheses: hyp_results = self.haim.query(hypothesis, top_k=top_k // 2) for node_id, sim in hyp_results: if node_id in all_results: # Boost score for memories relevant to multiple hypotheses all_results[node_id] = max(all_results[node_id], sim * 0.8) else: all_results[node_id] = sim * 0.6 # Sort by score and return top_k sorted_results = sorted(all_results.items(), key=lambda x: x[1], reverse=True) return sorted_results[:top_k] def _build_hypothesis_evaluation_prompt( self, query: str, hypotheses: List[str], relevant_memories: List[Dict] ) -> str: """Build prompt for multi-hypothesis evaluation""" prompt = f"""You are an AI with holographic memory. You have multiple hypotheses about a question, and you've retrieved relevant memories to evaluate them. Query: "{query}" Hypotheses: """ for i, hyp in enumerate(hypotheses, 1): prompt += f"\nHypothesis {i}: {hyp}" prompt += "\n\nRelevant Memories:\n" for i, mem in enumerate(relevant_memories, 1): prompt += f"\nMemory {i} (similarity: {mem['similarity']:.3f}):\n{mem['content']}\n" prompt += """ Task: Evaluate which hypothesis is most supported by the retrieved memories. - Consider all memories - Rank hypotheses by support from memory - Explain your reasoning - Provide confidence score (0-100%) for each hypothesis Evaluation:""" return prompt def consolidate_memory( self, node_id: str, new_context: str, success: bool = True ): """ Reconsolidate memory with new context Similar to how human memories are rewritten when recalled """ node = self.haim.tier_manager.get_memory(node_id) if not node: return # Access triggers reconsolidation node.access() # Update content with new context (simplified) # In production: use LLM to intelligently merge node.content = f"{node.content}\n\n[RECONSOLIDATED]: {new_context}" # Strengthen synaptic connections if consolidation was successful if success: # Find related concepts and strengthen # (This requires concept extraction - simplified for now) pass class MultiAgentHAIM: """ Multi-agent system with shared HAIM memory Demonstrates "collective consciousness" """ def __init__(self, num_agents: int = 3): self.agents = {} # agent_id -> HAIMEngine self.shared_memory = HAIMEngine(dimension=10000) # Initialize agents with shared memory for i in range(num_agents): agent_id = f"agent_{i}" self.agents[agent_id] = { "haim": self.shared_memory, # All share same memory "role": self._get_agent_role(agent_id) } def _get_agent_role(self, agent_id: str) -> str: """Define agent roles""" roles = { "agent_0": "Research Agent", "agent_1": "Coding Agent", "agent_2": "Writing Agent" } return roles.get(agent_id, "General Agent") def agent_learn( self, agent_id: str, content: str, metadata: dict = None ) -> str: """ Agent stores memory in shared HAIM All agents can access this memory """ if agent_id not in self.agents: raise AgentNotFoundError(agent_id) # Store in shared memory node_id = self.shared_memory.store(content, metadata) # Update metadata with agent info node = self.shared_memory.tier_manager.get_memory(node_id) if node: node.metadata = node.metadata or {} node.metadata["learned_by"] = agent_id node.metadata["agent_role"] = self.agents[agent_id]["role"] node.metadata["timestamp"] = datetime.now().isoformat() return node_id def agent_recall( self, agent_id: str, query: str, top_k: int = 5 ) -> List[Dict]: """ Agent recalls memory from shared HAIM Can access memories learned by ANY agent """ if agent_id not in self.agents: raise AgentNotFoundError(agent_id) # Query shared memory results = self.shared_memory.query(query, top_k=top_k) # Enrich with agent context enriched = [] for node_id, similarity in results: node = self.shared_memory.tier_manager.get_memory(node_id) if node: enriched.append({ "node_id": node_id, "content": node.content, "similarity": similarity, "metadata": node.metadata, "learned_by": node.metadata.get("learned_by", "unknown"), "agent_role": node.metadata.get("agent_role", "unknown") }) return enriched def cross_agent_learning( self, concept_a: str, concept_b: str, agent_id: str, success: bool = True ): """ Strengthen connection between concepts across agents When ANY agent fires this connection, ALL agents benefit """ if agent_id not in self.agents: raise AgentNotFoundError(agent_id) # Map concepts to memory IDs using holographic similarity mem_id_a = self._concept_to_memory_id(concept_a) mem_id_b = self._concept_to_memory_id(concept_b) if mem_id_a and mem_id_b: # Schedule binding in the background self._schedule_async_task( self.shared_memory.bind_memories(mem_id_a, mem_id_b, success=success) ) def _concept_to_memory_id(self, concept: str, min_similarity: float = 0.3) -> Optional[str]: """ Map a concept string to the best matching memory ID. Uses holographic similarity to find the most relevant stored memory. Returns the memory ID if found with sufficient similarity, else None. """ # Use synchronous encoding and search via tier manager for direct access query_vec = self.shared_memory.encode_content(concept) # Search in hot tier first (most recent/active memories) best_match_id = None best_similarity = 0.0 # Check HOT tier for node_id, node in self.shared_memory.tier_manager.hot.items(): sim = query_vec.similarity(node.hdv) if sim > best_similarity: best_similarity = sim best_match_id = node_id if best_similarity >= min_similarity: return best_match_id return None def _schedule_async_task(self, coro): """Schedule an async coroutine to run, handling the event loop appropriately.""" import asyncio try: loop = asyncio.get_running_loop() # We're in an async context, create a task loop.create_task(coro) except RuntimeError: # No running loop, run synchronously (for demo/testing purposes) try: asyncio.run(coro) except Exception: pass # Silently fail in demo mode async def collective_orch_or( self, agent_id: str, query: str, max_collapse: int = 3 ) -> List[Dict]: """ Agent performs Orch OR on shared memories Collapses superposition based on collective free energy """ if agent_id not in self.agents: raise AgentNotFoundError(agent_id) collapsed = await self.shared_memory.orchestrate_orch_or(max_collapse=max_collapse) # Enrich with agent context result = [] for node in collapsed: result.append({ "content": node.content, "free_energy_score": getattr(node, 'epistemic_value', 0.0), "metadata": node.metadata, "collapsed_by": agent_id, "agent_role": self.agents[agent_id]["role"] }) return result def demonstrate_collective_consciousness(self) -> Dict: """ Demonstrate cross-agent learning Shows that when Agent A learns, Agent B knows """ # Agent 0 (Research) learns something mem_0 = self.agent_learn( agent_id="agent_0", content="MnemoCore Market Integrity Engine uses three signal groups: SURGE, FLOW, PATTERN", metadata={"category": "research", "importance": "high"} ) # Agent 1 (Coding) learns something mem_1 = self.agent_learn( agent_id="agent_1", content="HAIM uses hyperdimensional vectors with 10,000 dimensions", metadata={"category": "coding", "importance": "high"} ) # Agent 2 (Writing) recalls BOTH memories recall_0 = self.agent_recall( agent_id="agent_2", query="MnemoCore Engine", top_k=1 ) recall_1 = self.agent_recall( agent_id="agent_2", query="HAIM dimensions", top_k=1 ) # Cross-agent learning: strengthen connection self.cross_agent_learning( concept_a="MnemoCore Engine", concept_b="HAIM dimensions", agent_id="agent_2", success=True ) return { "demonstration": "Collective Consciousness Demo", "agent_0_learned": mem_0, "agent_1_learned": mem_1, "agent_2_recalled_omega": recall_0, "agent_2_recalled_haim": recall_1, "cross_agent_connection": "Strengthened between Omega Engine and HAIM dimensions" } class RLMIntegrator: """ Phase 4.5: RLM (Recursive Language Models) Integrator. Bridges HAIMLLMIntegrator with the RecursiveSynthesizer to provide LLM-powered recursive memory queries. Usage:: integrator = RLMIntegrator(llm_integrator) result = await integrator.rlm_query( "What do we know about X and how does it relate to Y?" ) print(result["synthesis"]) Without an LLM configured, falls back to heuristic decomposition and score-based synthesis. """ def __init__(self, llm_integrator, config=None): from mnemocore.core.recursive_synthesizer import RecursiveSynthesizer, SynthesizerConfig self.llm_integrator = llm_integrator self.haim = llm_integrator.haim llm_call = None if llm_integrator.llm_client is not None: llm_call = llm_integrator._call_llm synth_config = config or SynthesizerConfig() self.synthesizer = RecursiveSynthesizer( engine=self.haim, config=synth_config, llm_call=llm_call, ) async def rlm_query(self, query, context_text=None, project_id=None): """ Execute a Phase 4.5 recursive memory query. Args: query: The user question (can be complex/multi-topic). context_text: Optional large external text (Ripple environment). project_id: Optional project scope for isolation masking. Returns: Dict: query, sub_queries, results, synthesis, max_depth_hit, elapsed_ms, ripple_snippets, stats """ from mnemocore.core.ripple_context import RippleContext ripple_ctx = None if context_text and context_text.strip(): ripple_ctx = RippleContext(text=context_text, source_label="api_context") result = await self.synthesizer.synthesize( query=query, ripple_context=ripple_ctx, project_id=project_id, ) return { "query": result.query, "sub_queries": result.sub_queries, "results": result.results, "synthesis": result.synthesis, "max_depth_hit": result.max_depth_hit, "elapsed_ms": result.total_elapsed_ms, "ripple_snippets": result.ripple_snippets, "stats": result.stats, } @classmethod def from_config(cls, haim_engine, llm_config, synth_config=None): """Create an RLMIntegrator directly from an LLMConfig.""" llm_integrator = HAIMLLMIntegrator.from_config(haim_engine, llm_config) return cls(llm_integrator=llm_integrator, config=synth_config) def create_demo(): """Create HAIM demo with multi-agent system""" print("Creating HAIM Multi-Agent Demo...") # Create multi-agent system multi_agent_haim = MultiAgentHAIM(num_agents=3) # Demonstrate collective consciousness result = multi_agent_haim.demonstrate_collective_consciousness() print("\n=== DEMO RESULT ===") print(json.dumps(result, indent=2)) return result if __name__ == "__main__": create_demo()