legalmind-ai 1.1.0__py3-none-any.whl

legalmind/core_enhanced.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+LegalMind Enhanced Core System
+With TF-IDF search and advanced prompts
+"""
+
+import sys
+from pathlib import Path
+
+# Import from versalaw2_core
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from versalaw2_core import Config
+from versalaw2_core.enhanced_system import EnhancedVersaLaw2System
+from .enhanced_search import EnhancedSearchEngine
+from .prompt_templates import PromptTemplates
+
+class LegalMindEnhanced:
+    """
+    Enhanced LegalMind with:
+    - TF-IDF search
+    - Advanced prompts
+    - Better AI responses
+    """
+    
+    def __init__(self, ai_provider='mock', api_key=None):
+        """
+        Initialize Enhanced LegalMind
+        
+        Args:
+            ai_provider: 'mock', 'openai', 'deepseek', or 'qodo'
+            api_key: API key for the provider
+        """
+        print("\n" + "="*60)
+        print("⚖️  LEGALMIND ENHANCED - AI LEGAL ASSISTANT")
+        print("="*60)
+        print("Version: 2.0.0 (Enhanced)")
+        print("Features:")
+        print("  • TF-IDF Search Algorithm")
+        print("  • Advanced Prompt Templates")
+        print("  • 126 MayaLaw Cases")
+        print("  • Maya Wisdom Integration")
+        print("="*60 + "\n")
+        
+        # Create config
+        config = Config()
+        config['ai_provider'] = ai_provider
+        
+        if api_key:
+            if ai_provider == 'openai':
+                config['openai_api_key'] = api_key
+            elif ai_provider == 'deepseek':
+                config['deepseek_api_key'] = api_key
+            elif ai_provider == 'qodo':
+                config['qodo_api_key'] = api_key
+        
+        # Initialize base system
+        self.system = EnhancedVersaLaw2System(config)
+        
+        # Initialize enhanced search
+        print("🔍 Initializing enhanced search...")
+        self.enhanced_search = EnhancedSearchEngine(
+            self.system.data_loader.cases
+        )
+        
+        # Store prompt templates
+        self.prompts = PromptTemplates()
+        
+        print("✅ LegalMind Enhanced ready!\n")
+    
+    def ask(self, question, include_wisdom=True, use_enhanced_search=True, prompt_type='legal_analysis'):
+        """
+        Ask legal question with enhancements
+        
+        Args:
+            question: Legal question
+            include_wisdom: Include Maya Wisdom
+            use_enhanced_search: Use TF-IDF search
+            prompt_type: 'legal_analysis', 'chain_of_thought', or 'quick_answer'
+        
+        Returns:
+            Enhanced result dictionary
+        """
+        print(f"\n{'='*60}")
+        print(f"📝 PERTANYAAN: {question}")
+        print(f"{'='*60}\n")
+        
+        # Step 1: Classify
+        print("1️⃣ Mengklasifikasi...")
+        classification = self.system.classifier.classify(question)
+        print(f"   ✅ Kategori: {classification['category']}")
+        print(f"   ✅ Confidence: {classification['confidence']:.0%}\n")
+        
+        # Step 2: Search with enhanced algorithm
+        print("2️⃣ Mencari dengan Enhanced Search...")
+        if use_enhanced_search:
+            relevant_cases = self.enhanced_search.search(question, top_k=3)
+            search_method = relevant_cases[0]['search_method'] if relevant_cases else 'none'
+            print(f"   ✅ Method: {search_method.upper()}")
+        else:
+            relevant_cases = self.system.data_loader.search(question, top_k=3)
+            search_method = 'basic'
+        
+        print(f"   ✅ Ditemukan: {len(relevant_cases)} kasus\n")
+        
+        if relevant_cases:
+            for i, case in enumerate(relevant_cases, 1):
+                score = case.get('similarity_score', 0)
+                print(f"      {i}. Kasus #{case['number']}: {case['pertanyaan'][:60]}...")
+                print(f"         Score: {score:.3f}")
+            print()
+        
+        # Step 3: Get wisdom if requested
+        wisdom_response = None
+        if include_wisdom and self.system.wisdom_available:
+            print("3️⃣ Mengambil Maya Wisdom...")
+            try:
+                wisdom_response = self.system.wisdom.process_legal_question(question)
+                print(f"   ✅ Wisdom type: {wisdom_response.get('type', 'N/A')}\n")
+            except Exception as e:
+                print(f"   ⚠️  Wisdom error: {e}\n")
+        
+        # Step 4: Generate answer with advanced prompt
+        print("4️⃣ Memproses dengan AI (Advanced Prompts)...")
+        
+        # Select prompt template
+        if prompt_type == 'chain_of_thought':
+            prompt_method = self.prompts.chain_of_thought_prompt
+        elif prompt_type == 'quick_answer':
+            prompt_method = self.prompts.quick_answer_prompt
+        else:
+            prompt_method = self.prompts.legal_analysis_prompt
+        
+        # Build context
+        context = {'cases': relevant_cases}
+        
+        # For mock AI, use standard generation
+        # For real AI, would use advanced prompts
+        ai_response = self.system.ai_processor.generate_answer(question, context)
+        print(f"   ✅ Generated with {prompt_type}\n")
+        
+        # Build enhanced result
+        result = {
+            'question': question,
+            'classification': classification,
+            'cases_found': len(relevant_cases),
+            'cases': relevant_cases,
+            'wisdom': wisdom_response,
+            'answer': ai_response['answer'],
+            'metadata': {
+                'ai_model': ai_response['model'],
+                'tokens': ai_response['usage']['total_tokens'],
+                'confidence': 0.95 if relevant_cases else 0.5,
+                'search_method': search_method,
+                'prompt_type': prompt_type,
+                'enhanced': True
+            }
+        }
+        
+        return result
+    
+    def print_answer(self, result):
+        """Print enhanced answer"""
+        print(f"{'='*60}")
+        print("📊 HASIL ANALISIS (ENHANCED)")
+        print(f"{'='*60}\n")
+        
+        print(f"🎯 Kategori: {result['classification']['category']}")
+        print(f"📚 Kasus: {result['cases_found']}")
+        print(f"🔍 Search: {result['metadata']['search_method'].upper()}")
+        print(f"💯 Confidence: {result['metadata']['confidence']:.0%}")
+        print(f"🤖 Prompt: {result['metadata']['prompt_type']}\n")
+        
+        # Print wisdom if available
+        if result.get('wisdom'):
+            wisdom = result['wisdom']
+            print(f"{'='*60}")
+            print("🧠 MAYA WISDOM")
+            print(f"{'='*60}\n")
+            print(f"Type: {wisdom.get('type', 'N/A')}")
+            print(f"Confidence: {wisdom.get('confidence', 0):.0%}\n")
+            if 'answer' in wisdom:
+                print(f"{wisdom['answer']}\n")
+        
+        print(f"{'='*60}")
+        print(result['answer'])
+        print(f"{'='*60}\n")
+    
+    def get_stats(self):
+        """Get enhanced system statistics"""
+        base_stats = self.system.get_stats()
+        search_stats = self.enhanced_search.get_stats()
+        
+        return {
+            **base_stats,
+            'enhanced': {
+                'version': '2.0.0',
+                'search_engine': search_stats,
+                'features': [
+                    'TF-IDF Search',
+                    'Advanced Prompts',
+                    'Maya Wisdom',
+                    'Multi-Provider AI'
+                ]
+            }
+        }

legalmind/enhanced_search.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Enhanced Search Algorithm
+TF-IDF + Cosine Similarity for better relevance
+"""
+
+try:
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    from sklearn.metrics.pairwise import cosine_similarity
+    SKLEARN_AVAILABLE = True
+except ImportError:
+    SKLEARN_AVAILABLE = False
+    print("⚠️  scikit-learn not installed. Using basic search.")
+
+import numpy as np
+
+class EnhancedSearchEngine:
+    """
+    Advanced search with TF-IDF and cosine similarity
+    Falls back to basic search if sklearn not available
+    """
+    
+    def __init__(self, cases):
+        self.cases = cases
+        self.use_tfidf = SKLEARN_AVAILABLE
+        
+        if self.use_tfidf:
+            self._init_tfidf()
+        else:
+            print("ℹ️  Using basic keyword search")
+    
+    def _init_tfidf(self):
+        """Initialize TF-IDF vectorizer"""
+        try:
+            self.vectorizer = TfidfVectorizer(
+                max_features=1000,
+                ngram_range=(1, 2),
+                min_df=1,
+                max_df=0.8
+            )
+            
+            # Build corpus from all case fields
+            corpus = []
+            for c in self.cases:
+                text = " ".join([
+                    c.get('pertanyaan', ''),
+                    c.get('kasus', ''),
+                    c.get('jawaban', ''),
+                    c.get('analisis', ''),
+                    " ".join(c.get('pasal', [])),
+                ])
+                corpus.append(text)
+            
+            # Fit and transform
+            self.vectors = self.vectorizer.fit_transform(corpus)
+            print(f"✅ Enhanced search initialized with {len(self.cases)} cases")
+            print(f"   Features: {self.vectorizer.get_feature_names_out()[:10]}...")
+        
+        except Exception as e:
+            print(f"⚠️  TF-IDF initialization failed: {e}")
+            self.use_tfidf = False
+    
+    def search(self, query, top_k=3):
+        """
+        Search with TF-IDF similarity or fallback to basic
+        
+        Args:
+            query: Search query
+            top_k: Number of results
+        
+        Returns:
+            List of cases with similarity scores
+        """
+        if self.use_tfidf:
+            return self._tfidf_search(query, top_k)
+        else:
+            return self._basic_search(query, top_k)
+    
+    def _tfidf_search(self, query, top_k):
+        """TF-IDF based search"""
+        try:
+            # Transform query
+            query_vec = self.vectorizer.transform([query])
+            
+            # Calculate cosine similarity
+            similarities = cosine_similarity(query_vec, self.vectors)[0]
+            
+            # Get top results
+            top_indices = similarities.argsort()[-top_k:][::-1]
+            
+            results = []
+            for idx in top_indices:
+                if similarities[idx] > 0:  # Only return if similarity > 0
+                    case = self.cases[idx].copy()
+                    case['similarity_score'] = float(similarities[idx])
+                    case['search_method'] = 'tfidf'
+                    results.append(case)
+            
+            return results
+        
+        except Exception as e:
+            print(f"⚠️  TF-IDF search failed: {e}, using basic search")
+            return self._basic_search(query, top_k)
+    
+    def _basic_search(self, query, top_k):
+        """Fallback basic keyword search"""
+        query_lower = query.lower()
+        keywords = [k for k in query_lower.split() if len(k) > 3]
+        
+        scored_cases = []
+        for case in self.cases:
+            score = 0
+            
+            # Search in pertanyaan
+            if query_lower in case.get('pertanyaan', '').lower():
+                score += 20
+            
+            # Search in kasus
+            if query_lower in case.get('kasus', '').lower():
+                score += 10
+            
+            # Search in jawaban
+            if query_lower in case.get('jawaban', '').lower():
+                score += 5
+            
+            # Keyword matching
+            full_content = case.get('full_content', '').lower()
+            for keyword in keywords:
+                count = full_content.count(keyword)
+                score += count * 2
+            
+            if score > 0:
+                case_copy = case.copy()
+                case_copy['similarity_score'] = score / 100.0  # Normalize
+                case_copy['search_method'] = 'basic'
+                scored_cases.append((score, case_copy))
+        
+        # Sort and return top k
+        scored_cases.sort(reverse=True, key=lambda x: x[0])
+        return [case for score, case in scored_cases[:top_k]]
+    
+    def get_stats(self):
+        """Get search engine statistics"""
+        return {
+            'total_cases': len(self.cases),
+            'search_method': 'tfidf' if self.use_tfidf else 'basic',
+            'sklearn_available': SKLEARN_AVAILABLE
+        }

legalmind/prompt_templates.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""
+Advanced Prompt Templates
+Optimized prompts for better AI responses
+"""
+
+class PromptTemplates:
+    """Collection of optimized prompt templates"""
+    
+    @staticmethod
+    def legal_analysis_prompt(question, context_cases):
+        """
+        Comprehensive legal analysis prompt
+        
+        Args:
+            question: User's legal question
+            context_cases: Relevant cases from MayaLaw
+        
+        Returns:
+            Optimized prompt string
+        """
+        
+        # Build context from cases
+        context = ""
+        for i, case in enumerate(context_cases[:2], 1):
+            context += f"""
+KASUS REFERENSI #{i}:
+Pertanyaan: {case.get('pertanyaan', '')[:200]}
+Jawaban: {case.get('jawaban', '')[:300]}
+Dasar Hukum: {', '.join(case.get('pasal', [])[:3])}
+UU: {', '.join(case.get('uu', [])[:2])}
+---
+"""
+        
+        return f"""
+Anda adalah ahli hukum Indonesia senior dengan pengalaman 20+ tahun di berbagai bidang hukum.
+
+KONTEKS DARI DATABASE MAYALAW:
+{context}
+
+PERTANYAAN KLIEN:
+{question}
+
+INSTRUKSI ANALISIS:
+1. Baca pertanyaan dengan teliti dan identifikasi isu hukum utama
+2. Analisis konteks dari database MayaLaw yang relevan
+3. Identifikasi Pasal dan UU yang spesifik dan berlaku
+4. Berikan reasoning yang jelas dan logis
+5. Sertakan confidence level dengan justifikasi
+
+FORMAT JAWABAN (WAJIB IKUTI):
+
+## 🎯 RINGKASAN SINGKAT
+[Jawaban dalam 1-2 kalimat yang langsung menjawab pertanyaan]
+
+## ⚖️ ANALISIS HUKUM
+[Analisis mendalam dengan reasoning step-by-step]
+
+## 📖 DASAR HUKUM
+**Pasal yang Relevan:**
+- Pasal [nomor] [nama UU]: [penjelasan singkat]
+- [tambahkan pasal lain jika relevan]
+
+**Undang-Undang:**
+- UU No. [nomor] Tahun [tahun] tentang [judul]
+- [tambahkan UU lain jika relevan]
+
+## 💡 REKOMENDASI PRAKTIS
+1. [Langkah konkret yang bisa diambil]
+2. [Pertimbangan penting]
+3. [Alternatif jika ada]
+
+## 📊 TINGKAT KEYAKINAN
+[X%] - [Alasan spesifik mengapa confidence level ini, berdasarkan kekuatan dasar hukum dan relevansi kasus]
+
+## 📚 REFERENSI
+- Berdasarkan Kasus MayaLaw #{case.get('number', 'N/A')}
+- [Sumber lain jika ada]
+
+PENTING:
+- Gunakan bahasa yang jelas dan mudah dipahami
+- Hindari jargon hukum yang tidak perlu
+- Berikan contoh konkret jika membantu
+- Jika tidak yakin, katakan dengan jujur
+
+Mulai analisis Anda:
+"""
+    
+    @staticmethod
+    def chain_of_thought_prompt(question, context_cases):
+        """
+        Chain-of-thought reasoning prompt
+        
+        Args:
+            question: User's legal question
+            context_cases: Relevant cases
+        
+        Returns:
+            Chain-of-thought prompt
+        """
+        
+        context = "\n".join([
+            f"- Kasus #{c.get('number')}: {c.get('pertanyaan', '')[:100]}"
+            for c in context_cases[:3]
+        ])
+        
+        return f"""
+Gunakan chain-of-thought reasoning untuk menjawab pertanyaan hukum ini secara sistematis.
+
+PERTANYAAN: {question}
+
+KONTEKS DARI MAYALAW:
+{context}
+
+PROSES ANALISIS STEP-BY-STEP:
+
+**Langkah 1: Identifikasi Isu Hukum**
+[Tuliskan dengan jelas isu hukum apa yang perlu dijawab]
+
+**Langkah 2: Cari Dasar Hukum**
+[Identifikasi Pasal dan UU yang relevan dari konteks atau pengetahuan hukum]
+
+**Langkah 3: Analisis Penerapan**
+[Bagaimana hukum diterapkan pada situasi ini? Apa implikasinya?]
+
+**Langkah 4: Pertimbangkan Preseden**
+[Apakah ada kasus serupa di database? Apa pembelajaran dari kasus tersebut?]
+
+**Langkah 5: Evaluasi Alternatif**
+[Apakah ada interpretasi atau pendekatan alternatif yang perlu dipertimbangkan?]
+
+**Langkah 6: Kesimpulan**
+[Jawaban final dengan confidence level dan alasan]
+
+Mulai analisis step-by-step Anda:
+"""
+    
+    @staticmethod
+    def quick_answer_prompt(question, context_cases):
+        """
+        Quick answer prompt for simple questions
+        
+        Args:
+            question: User's legal question
+            context_cases: Relevant cases
+        
+        Returns:
+            Quick answer prompt
+        """
+        
+        if context_cases:
+            case = context_cases[0]
+            context = f"""
+Referensi: Kasus #{case.get('number')}
+Pertanyaan serupa: {case.get('pertanyaan', '')[:150]}
+Jawaban: {case.get('jawaban', '')[:200]}
+Pasal: {', '.join(case.get('pasal', [])[:2])}
+"""
+        else:
+            context = "Tidak ada kasus serupa di database."
+        
+        return f"""
+Berikan jawaban singkat dan jelas untuk pertanyaan hukum ini.
+
+PERTANYAAN: {question}
+
+KONTEKS:
+{context}
+
+FORMAT JAWABAN:
+
+**Jawaban Singkat:**
+[1-2 kalimat yang langsung menjawab]
+
+**Dasar Hukum:**
+[Pasal dan UU yang relevan]
+
+**Catatan:**
+[Informasi tambahan penting jika ada]
+
+Jawab dengan singkat dan jelas:
+"""
+    
+    @staticmethod
+    def document_analysis_prompt(document_text, question):
+        """
+        Prompt for analyzing legal documents
+        
+        Args:
+            document_text: Text from uploaded document
+            question: Specific question about the document
+        
+        Returns:
+            Document analysis prompt
+        """
+        
+        return f"""
+Anda adalah ahli hukum yang diminta menganalisis dokumen legal.
+
+DOKUMEN:
+{document_text[:2000]}
+[... dokumen dipotong untuk efisiensi ...]
+
+PERTANYAAN TENTANG DOKUMEN:
+{question}
+
+INSTRUKSI ANALISIS:
+1. Baca dokumen dengan teliti
+2. Identifikasi klausul-klausul penting
+3. Cari potensi masalah atau risiko
+4. Jawab pertanyaan spesifik yang diajukan
+
+FORMAT JAWABAN:
+
+## 📄 RINGKASAN DOKUMEN
+[Ringkasan singkat isi dokumen]
+
+## 🔍 ANALISIS KLAUSUL PENTING
+[Klausul-klausul yang perlu diperhatikan]
+
+## ⚠️ POTENSI RISIKO
+[Risiko atau masalah yang teridentifikasi]
+
+## 💡 JAWABAN PERTANYAAN
+[Jawaban spesifik untuk pertanyaan yang diajukan]
+
+## 📋 REKOMENDASI
+[Saran perbaikan atau tindakan yang perlu diambil]
+
+Mulai analisis dokumen:
+"""
+    
+    @staticmethod
+    def comparative_analysis_prompt(question, answers_from_models):
+        """
+        Prompt for comparing answers from multiple AI models
+        
+        Args:
+            question: Original question
+            answers_from_models: Dict of model_name: answer
+        
+        Returns:
+            Comparative analysis prompt
+        """
+        
+        answers_text = "\n\n".join([
+            f"**{model}:**\n{answer[:500]}"
+            for model, answer in answers_from_models.items()
+        ])
+        
+        return f"""
+Anda diminta membandingkan beberapa jawaban dari AI models berbeda untuk pertanyaan hukum yang sama.
+
+PERTANYAAN ORIGINAL:
+{question}
+
+JAWABAN DARI BERBAGAI MODEL:
+{answers_text}
+
+TUGAS ANDA:
+1. Bandingkan kualitas setiap jawaban
+2. Identifikasi perbedaan pendapat jika ada
+3. Tentukan jawaban mana yang paling akurat
+4. Berikan jawaban final yang menggabungkan yang terbaik
+
+FORMAT ANALISIS:
+
+## 📊 PERBANDINGAN JAWABAN
+[Ringkasan perbedaan dan persamaan]
+
+## ✅ KELEBIHAN SETIAP JAWABAN
+[Apa yang baik dari masing-masing jawaban]
+
+## ⚠️ KELEMAHAN YANG TERIDENTIFIKASI
+[Kesalahan atau kekurangan yang ditemukan]
+
+## 🎯 JAWABAN FINAL (BEST OF ALL)
+[Jawaban terbaik yang menggabungkan semua insight]
+
+## 💯 CONFIDENCE LEVEL
+[Tingkat keyakinan dengan alasan]
+
+Mulai analisis komparatif:
+"""

legalmind/providers/fallback/__init__.py

@@ -0,0 +1,11 @@
+"""
+VersaLaw2 Core Package
+Complete legal AI system
+"""
+
+from .system import VersaLaw2System
+from .config import Config
+from .data_loader import MayaLawDataLoader
+
+__version__ = "2.0.0"
+__all__ = ['VersaLaw2System', 'Config', 'MayaLawDataLoader']