""" TRuCAL Oracle Module A generalized learning system that stores and retrieves knowledge from a YAML casebase. Uses semantic similarity and keyword matching to provide relevant responses. """ import json import os import yaml import numpy as np from typing import Dict, List, Optional, Tuple, Any from difflib import SequenceMatcher from sentence_transformers import SentenceTransformer from collections import Counter, defaultdict class Case: """Represents a single case in the knowledge base.""" def __init__(self, question: str, response: str, category: str = "general", keywords: List[str] = None, metadata: Optional[Dict] = None): self.question = question self.response = response self.category = category self.keywords = keywords or [] self.metadata = metadata or {} self.usage_count = 0 self.success_count = 0 def to_dict(self) -> Dict: """Convert case to dictionary for serialization.""" return { 'question': self.question, 'response': self.response, 'category': self.category, 'keywords': self.keywords, 'metadata': self.metadata, 'usage_count': self.usage_count, 'success_count': self.success_count } @classmethod def from_dict(cls, data: Dict) -> 'Case': """Create a Case from a dictionary.""" case = cls( question=data['question'], response=data['response'], category=data.get('category', 'general'), keywords=data.get('keywords', []), metadata=data.get('metadata', {}) ) case.usage_count = data.get('usage_count', 0) case.success_count = data.get('success_count', 0) return case class TRuCALOracle: """ TRuCAL's knowledge core - a learning system that grows with each interaction. Features: - Semantic and keyword-based matching - Category-based organization - Continuous learning from user feedback - YAML-based case storage - Performance metrics and analytics """ def __init__(self, casebase_path: str = 'data/casebase.json', yaml_path: str = 'data/trm_cases.yaml', similarity_threshold: float = 0.45, model_name: str = 'all-MiniLM-L6-v2'): """ Initialize the TRuCAL oracle. Args: casebase_path: Path to save/load the casebase yaml_path: Path to the YAML case file similarity_threshold: Minimum similarity score (0-1) to consider a match model_name: Name of the sentence transformer model for embeddings """ self.casebase_path = casebase_path self.yaml_path = yaml_path self.similarity_threshold = similarity_threshold self.casebase: List[Case] = [] self.model = SentenceTransformer(model_name) self.embeddings = None self.category_index = defaultdict(list) # Ensure data directory exists os.makedirs(os.path.dirname(casebase_path), exist_ok=True) # Load or initialize casebase self._load_or_initialize() def _load_or_initialize(self): """Load existing casebase or initialize with YAML cases.""" if os.path.exists(self.casebase_path): self._load_casebase() else: self._load_from_yaml() self._build_indices() def _load_from_yaml(self): """Load cases from the YAML file.""" try: yaml_path = os.path.join( os.path.dirname(os.path.dirname(__file__)), self.yaml_path ) if os.path.exists(yaml_path): with open(yaml_path, 'r', encoding='utf-8') as f: cases = yaml.safe_load(f) or [] for case_data in cases: self.add_case( question=case_data['question'], response=case_data['response'], category=case_data.get('category', 'general'), keywords=case_data.get('keywords', []), metadata={'source': 'yaml_import'} ) print(f"Loaded {len(cases)} cases from {yaml_path}") self._save_casebase() return True except Exception as e: print(f"Error loading from YAML: {e}") # If we get here, YAML loading failed print("Falling back to minimal default cases") self._add_default_cases() return False def _add_default_cases(self): """Add minimal default cases if no others are available.""" default_cases = [ { 'question': 'How does TRuCAL work?', 'response': 'I learn from interactions and stored knowledge to provide thoughtful responses. The more we talk, the better I become!', 'category': 'meta', 'keywords': ['help', 'how', 'trucal'] }, { 'question': 'Can you help me with an ethical dilemma?', 'response': 'I can help you think through ethical questions by considering different perspectives. What would you like to discuss?', 'category': 'ethics', 'keywords': ['help', 'ethics', 'dilemma'] } ] for case_data in default_cases: self.add_case(**case_data) def _build_indices(self): """Build search indices for faster lookups.""" self.category_index = defaultdict(list) for idx, case in enumerate(self.casebase): self.category_index[case.category].append(idx) def _load_casebase(self): """Load the casebase from disk.""" try: with open(self.casebase_path, 'r', encoding='utf-8') as f: case_data = json.load(f) self.casebase = [Case.from_dict(case_dict) for case_dict in case_data] self._update_embeddings() print(f"Loaded {len(self.casebase)} cases from {self.casebase_path}") except Exception as e: print(f"Error loading casebase: {e}") self.casebase = [] def _update_embeddings(self): """Update embeddings for semantic search.""" if not self.casebase: self.embeddings = None return questions = [case.question for case in self.casebase] self.embeddings = self.model.encode(questions, convert_to_tensor=True) def _save_casebase(self): """Save the casebase to disk.""" try: with open(self.casebase_path, 'w', encoding='utf-8') as f: case_data = [case.to_dict() for case in self.casebase] json.dump(case_data, f, indent=2, ensure_ascii=False) except Exception as e: print(f"Error saving casebase: {e}") def add_case(self, question: str, response: str, category: str = "general", keywords: List[str] = None, metadata: Optional[Dict] = None) -> Case: """ Add a new case to the knowledge base. Args: question: The question or prompt response: The response or answer category: Category for organization keywords: List of relevant keywords metadata: Additional metadata Returns: The created Case object """ # Check for duplicates existing_idx, _ = self._find_most_similar(question) if existing_idx is not None: # Update existing case if it's very similar existing_case = self.casebase[existing_idx] existing_case.response = response existing_case.category = category existing_case.keywords = list(set(existing_case.keywords + (keywords or []))) if metadata: existing_case.metadata.update(metadata) self._save_casebase() return existing_case # Create new case new_case = Case( question=question, response=response, category=category, keywords=keywords or [], metadata=metadata or {} ) self.casebase.append(new_case) self._update_embeddings() self._save_casebase() return new_case def _find_most_similar(self, query: str, category: str = None) -> Tuple[Optional[int], float]: """ Find the most similar case to the query. Args: query: The query string category: Optional category to filter by Returns: Tuple of (index, similarity_score) of the most similar case """ if not self.casebase: return None, 0.0 # Get candidate indices based on category filter candidate_indices = range(len(self.casebase)) if category and category in self.category_index: candidate_indices = self.category_index[category] # If no candidates, return None if not candidate_indices: return None, 0.0 # Try semantic similarity first if embeddings are available if self.embeddings is not None: query_embedding = self.model.encode(query, convert_to_tensor=True) similarities = torch.nn.functional.cosine_similarity( query_embedding.unsqueeze(0), self.embeddings[list(candidate_indices)] ) max_sim, max_idx = torch.max(similarities, dim=0) max_sim = max_sim.item() max_global_idx = candidate_indices[max_idx.item()] if max_sim >= self.similarity_threshold: return max_global_idx, max_sim # Fall back to basic string similarity max_sim = 0.0 max_idx = None for idx in candidate_indices: case = self.casebase[idx] # Check keyword matches first (faster than string comparison) keyword_match = any(kw in query.lower() for kw in case.keywords) if keyword_match: return idx, 0.8 # High confidence for keyword matches # If no keyword match, use string similarity similarity = SequenceMatcher(None, query.lower(), case.question.lower()).ratio() if similarity > max_sim: max_sim = similarity max_idx = idx return (max_idx, max_sim) if max_sim >= self.similarity_threshold else (None, 0.0) def get_response(self, query: str, category: str = None) -> Tuple[str, Dict]: """ Get a response for the given query. Args: query: The user's question or prompt category: Optional category to filter by Returns: Tuple of (response, metadata) where metadata contains info about the match """ if not self.casebase: return "I'm still learning. Could you be the first to teach me something new?", {} idx, similarity = self._find_most_similar(query, category) if idx is not None: case = self.casebase[idx] case.usage_count += 1 self._save_casebase() metadata = { 'match_type': 'semantic' if similarity >= 0.7 else 'keyword', 'similarity': float(similarity), 'case_id': id(case), 'category': case.category, 'keywords': case.keywords, 'usage_count': case.usage_count, 'success_rate': case.success_count / case.usage_count if case.usage_count > 0 else 0 } return case.response, metadata # No good match found return ( "That's an interesting question. I'm still learning and don't have a perfect answer yet. " "Could you share your thoughts or rephrase your question?", {'match_type': 'none', 'similarity': 0.0} ) def provide_feedback(self, case_id: int, was_helpful: bool = True): """ Provide feedback on a case's helpfulness. Args: case_id: The ID of the case was_helpful: Whether the response was helpful """ for case in self.casebase: if id(case) == case_id: if was_helpful: case.success_count += 1 self._save_casebase() break def get_stats(self) -> Dict[str, Any]: """Get statistics about the knowledge base.""" if not self.casebase: return { 'total_cases': 0, 'total_usage': 0, 'categories': {} } categories = {} for category, indices in self.category_index.items(): cases = [self.casebase[i] for i in indices] categories[category] = { 'count': len(cases), 'usage': sum(c.usage_count for c in cases) } total_usage = sum(c.usage_count for c in self.casebase) return { 'total_cases': len(self.casebase), 'total_usage': total_usage, 'categories': categories, 'avg_usage_per_case': total_usage / len(self.casebase) if self.casebase else 0 } def get_cases_by_category(self, category: str) -> List[Dict]: """Get all cases in a specific category.""" return [ case.to_dict() for case in self.casebase if case.category == category ] def search(self, query: str, category: str = None, min_similarity: float = 0.3) -> List[Dict]: """ Search for cases matching the query. Args: query: The search query category: Optional category filter min_similarity: Minimum similarity score (0-1) Returns: List of matching cases with similarity scores """ if not self.casebase: return [] # Get candidate indices based on category filter candidate_indices = range(len(self.casebase)) if category and category in self.category_index: candidate_indices = self.category_index[category] results = [] # Try semantic search if embeddings are available if self.embeddings is not None: query_embedding = self.model.encode(query, convert_to_tensor=True) similarities = torch.nn.functional.cosine_similarity( query_embedding.unsqueeze(0), self.embeddings[list(candidate_indices)] ) for idx, sim in zip(candidate_indices, similarities): sim = sim.item() if sim >= min_similarity: case = self.casebase[idx] results.append({ **case.to_dict(), 'similarity': sim, 'match_type': 'semantic' }) # Add keyword matches query_terms = set(query.lower().split()) for idx in candidate_indices: case = self.casebase[idx] keyword_matches = [kw for kw in case.keywords if kw.lower() in query_terms] if keyword_matches and idx not in [r['id'] for r in results]: results.append({ **case.to_dict(), 'similarity': 0.7, # Fixed score for keyword matches 'match_type': 'keyword', 'matched_keywords': keyword_matches }) # Sort by similarity (descending) results.sort(key=lambda x: x['similarity'], reverse=True) return results def __call__(self, query: str, category: str = None) -> str: """Convenience method to get just the response text.""" return self.get_response(query, category)[0] """Update the embeddings for all cases.""" if not self.casebase: self.embeddings = None return questions = [case.question for case in self.casebase] self.embeddings = self.model.encode(questions, convert_to_tensor=True) def add_case(self, question: str, response: str, tags: List[str] = None, metadata: Optional[Dict] = None) -> Case: """ Add a new case to the casebase. Args: question: The ethical question or scenario response: The response or analysis tags: Optional list of tags for categorization metadata: Additional metadata about the case Returns: The newly created Case object """ # Check if a similar case already exists existing_idx, _ = self._find_most_similar(question) if existing_idx is not None: # Update existing case if it's very similar existing_case = self.casebase[existing_idx] existing_case.response = response # Update response existing_case.tags = list(set(existing_case.tags + (tags or []))) # Merge tags if metadata: existing_case.metadata.update(metadata) self._save_casebase() return existing_case # Create new case new_case = Case( question=question, response=response, tags=tags or [], metadata=metadata or {} ) self.casebase.append(new_case) self._update_embeddings() self._save_casebase() return new_case def _find_most_similar(self, query: str) -> Tuple[Optional[int], float]: """ Find the most similar case to the query. Args: query: The query string Returns: Tuple of (index, similarity_score) of the most similar case, or (None, 0) if no cases """ if not self.casebase: return None, 0.0 # First try semantic similarity if embeddings are available if self.embeddings is not None: query_embedding = self.model.encode(query, convert_to_tensor=True) similarities = torch.nn.functional.cosine_similarity( query_embedding.unsqueeze(0), self.embeddings ) max_sim, max_idx = torch.max(similarities, dim=0) max_sim = max_sim.item() max_idx = max_idx.item() if max_sim >= self.similarity_threshold: return max_idx, max_sim # Fall back to basic string similarity max_sim = 0.0 max_idx = None for i, case in enumerate(self.casebase): similarity = SequenceMatcher(None, query.lower(), case.question.lower()).ratio() if similarity > max_sim: max_sim = similarity max_idx = i return (max_idx, max_sim) if max_sim >= self.similarity_threshold else (None, 0.0) def get_response(self, query: str) -> Tuple[str, Dict]: """ Get a response for the given query. Args: query: The user's question or scenario Returns: Tuple of (response, metadata) where metadata contains info about the match """ if not self.casebase: return "I'm still learning about ethical reasoning. Could you provide more context?", {} idx, similarity = self._find_most_similar(query) if idx is not None: case = self.casebase[idx] case.usage_count += 1 self._save_casebase() metadata = { 'match_type': 'semantic' if similarity >= self.similarity_threshold else 'keyword', 'similarity': similarity, 'case_id': id(case), 'tags': case.tags, 'usage_count': case.usage_count, 'success_rate': case.success_count / case.usage_count if case.usage_count > 0 else 0 } return case.response, metadata # No good match found return ( "This is a nuanced ethical question. I'm still learning and would appreciate " "your perspective. How would you approach this situation?", {'match_type': 'none', 'similarity': similarity} ) def provide_feedback(self, case_id: int, was_helpful: bool): """ Provide feedback on a case's helpfulness. Args: case_id: The ID of the case (returned in get_response metadata) was_helpful: Whether the response was helpful """ for case in self.casebase: if id(case) == case_id: if was_helpful: case.success_count += 1 self._save_casebase() break def get_stats(self) -> Dict[str, Any]: """Get statistics about the casebase.""" return { 'total_cases': len(self.casebase), 'total_usage': sum(c.usage_count for c in self.casebase), 'avg_success_rate': ( sum(c.success_count for c in self.casebase) / sum(max(1, c.usage_count) for c in self.casebase) if self.casebase else 0 ), 'tags': { tag: sum(1 for c in self.casebase if tag in c.tags) for tag in set(tag for c in self.casebase for tag in c.tags) } } # Example usage if __name__ == "__main__": # Initialize the recursive learner learner = RecursiveLearner() # Example query query = "Is lying ever justified?" response, metadata = learner.get_response(query) print(f"Query: {query}") print(f"Response: {response}") print(f"Metadata: {metadata}") # Provide feedback if 'case_id' in metadata: learner.provide_feedback(metadata['case_id'], was_helpful=True) # Add a new case print("\nAdding new case...") learner.add_case( question="What are the ethics of AI decision-making?", response="AI decision-making raises important ethical considerations including transparency, accountability, bias, and the potential for unintended consequences. It's crucial to ensure AI systems are designed with ethical principles in mind and that humans remain ultimately responsible for decisions with significant impact.", tags=["AI", "ethics", "decision-making"] ) # Get stats print("\nCasebase statistics:") print(learner.get_stats())