Update git-chat application with improved LLM integration and configuration

.env.example

@@ -1,14 +1,18 @@
-# Hugging Face API Token (optional, for better rate limits)
-HUGGINGFACE_API_KEY=your_huggingface_token_here
+# Groq API Key (recommended for fast and reliable LLM responses)
+GROQ_API_KEY=your_groq_api_key_here
 
 # GitHub Token (optional, for private repos or better rate limits)
 GITHUB_TOKEN=your_github_token_here
 
 # LLM Provider Configuration
-LLM_PROVIDER=huggingface
+LLM_PROVIDER=groq
 EMBEDDING_PROVIDER=sentence_transformers
 
-# Hugging Face Configuration
+# Groq Configuration
+GROQ_MODEL=deepseek-r1-distill-llama-70b
+
+# Hugging Face API Token (optional fallback)
+HUGGINGFACE_API_KEY=your_huggingface_token_here
 HUGGINGFACE_MODEL=microsoft/DialoGPT-medium
 
 # Embedding Model Configuration

README.md

@@ -42,10 +42,10 @@ A powerful AI-powered application that allows you to analyze any GitHub reposito
 ## 🛠️ Technology Stack
 
 - **Frontend**: Gradio for the user interface
-- **AI/ML**: Hugging Face Transformers, Sentence Transformers
+- **AI/ML**: Groq API for fast LLM inference, Sentence Transformers for embeddings
 - **Vector Database**: ChromaDB for storing code embeddings
 - **Code Processing**: GitPython for repository cloning
-- **Language Models**: Hugging Face Inference API
+- **Language Models**: Groq API with DeepSeek-R1-Distill-Llama-70B
 
 ## 📁 Supported File Types
 
@@ -56,7 +56,13 @@ The application processes the following file types:
 
 ## 🔧 Configuration
 
-The app uses Hugging Face's free inference API and Sentence Transformers for embeddings. No additional setup required!
+The app uses Groq's fast and reliable API for LLM inference and Sentence Transformers for embeddings. To get started:
+
+1. Get a free API key from [Groq](https://console.groq.com/)
+2. Set your API key in the environment variable `GROQ_API_KEY` 
+3. The app is pre-configured to use the powerful `deepseek-r1-distill-llama-70b` model
+
+No additional setup required - just add your Groq API key!
 
 ## 📝 Usage Tips
 

app.py

@@ -25,9 +25,9 @@ embedding_service = FreeEmbeddingService(
 
 # Initialize chat service for Hugging Face
 chat_service = FreeChatService(
-    llm_provider="huggingface",
-    api_key= os.environ["HUGGINGFACE_API_KEY"],
-    model="microsoft/DialoGPT-medium"
+    llm_provider=settings.llm_provider.value,
+    api_key=settings.huggingface_api_key,
+    model=settings.huggingface_model
 )
 
 file_processor = FileProcessor(settings.supported_extensions, settings.max_file_size)

config.py

@@ -6,6 +6,7 @@ class LLMProvider(str, Enum):
     OLLAMA = "ollama"
     GROQ = "groq"
     HUGGINGFACE = "huggingface"
+    SIMPLE = "simple"
 
 class EmbeddingProvider(str, Enum):
     SENTENCE_TRANSFORMERS = "sentence_transformers"
@@ -13,11 +14,11 @@ class EmbeddingProvider(str, Enum):
 
 class Settings(BaseSettings):
     # LLM Configuration
-    llm_provider: LLMProvider = LLMProvider.HUGGINGFACE
+    llm_provider: LLMProvider = LLMProvider.GROQ
     ollama_base_url: str = "http://localhost:11434"
     ollama_model: str = "llama2"
-    groq_api_key: str = ""
-    groq_model: str = "mixtral-8x7b-32768"
+    groq_api_key: str = os.getenv("GROQ_API_KEY", "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")
+    groq_model: str = "deepseek-r1-distill-llama-70b"
     huggingface_api_key: str = os.getenv("HUGGINGFACE_API_KEY", "")
     huggingface_model: str = "microsoft/DialoGPT-medium"
     

requirements.txt

@@ -10,7 +10,7 @@ python-dotenv==1.0.0
 aiofiles==23.2.1
 sentence-transformers==2.2.2
 transformers==4.36.0
-torch==2.1.0
+torch>=2.2.0
 huggingface-hub==0.19.4
 requests==2.31.0
 numpy==1.24.3

services/chat_service.py

@@ -5,6 +5,7 @@ from typing import Dict, List
 import json
 import requests
 import os
+from .simple_llm import NoAPILLM
 
 # For Groq (free tier available)
 class GroqLLM:
@@ -37,26 +38,85 @@ class GroqLLM:
         else:
             raise Exception(f"Groq API error: {response.text}")
 
-# For Hugging Face Inference API
+# For Hugging Face Inference API (with fallback to local transformers)
 class HuggingFaceLLM:
-    def __init__(self, api_key: str, model: str = "microsoft/DialoGPT-medium"):
+    def __init__(self, api_key: str = "", model: str = "microsoft/DialoGPT-medium"):
         self.api_key = api_key
         self.model = model
-        self.base_url = f"https://api-inference.huggingface.co/models/{model}"
+        self.use_local = not api_key or api_key == "your_huggingface_token_here"
+        
+        if self.use_local:
+            try:
+                from transformers import pipeline
+                print(f"Loading local model: {model}")
+                self.pipeline = pipeline("text-generation", model="gpt2", max_length=200)
+                print("✅ Local model loaded successfully!")
+            except ImportError:
+                raise Exception("transformers library not installed. Run: pip install transformers torch")
+            except Exception as e:
+                raise Exception(f"Failed to load local model: {str(e)}")
+        else:
+            self.base_url = f"https://api-inference.huggingface.co/models/{model}"
     
     def __call__(self, prompt: str) -> str:
+        if self.use_local:
+            try:
+                # Use local transformers pipeline
+                result = self.pipeline(prompt, max_length=len(prompt.split()) + 100, num_return_sequences=1)
+                generated_text = result[0]["generated_text"]
+                # Remove the input prompt from the response
+                if generated_text.startswith(prompt):
+                    generated_text = generated_text[len(prompt):].strip()
+                return generated_text if generated_text else "I understand your question about the code repository."
+            except Exception as e:
+                return f"Local model error: {str(e)}"
+        
+        # Original API-based approach
         headers = {"Authorization": f"Bearer {self.api_key}"}
-        data = {"inputs": prompt, "parameters": {"max_length": 1000, "temperature": 0.1}}
+        
+        # Use conversational format for DialoGPT
+        if "DialoGPT" in self.model:
+            data = {
+                "inputs": {
+                    "past_user_inputs": [],
+                    "generated_responses": [],
+                    "text": prompt
+                }
+            }
+        else:
+            # Standard text generation format
+            data = {
+                "inputs": prompt,
+                "parameters": {
+                    "max_length": 500,
+                    "temperature": 0.7,
+                    "do_sample": True
+                }
+            }
         
         response = requests.post(self.base_url, headers=headers, json=data)
         
         if response.status_code == 200:
             result = response.json()
+            
+            # Handle DialoGPT response format
+            if "DialoGPT" in self.model and isinstance(result, dict):
+                return result.get("generated_text", str(result))
+            
+            # Handle standard text generation response
             if isinstance(result, list) and len(result) > 0:
-                return result[0].get("generated_text", "").replace(prompt, "").strip()
+                generated_text = result[0].get("generated_text", "")
+                # Clean up the response by removing the input prompt
+                if generated_text.startswith(prompt):
+                    generated_text = generated_text[len(prompt):].strip()
+                return generated_text
+            elif isinstance(result, dict) and "generated_text" in result:
+                return result["generated_text"]
             return str(result)
         else:
-            raise Exception(f"HuggingFace API error: {response.text}")
+            # More detailed error information
+            error_msg = f"Status: {response.status_code}, Response: {response.text}"
+            raise Exception(f"HuggingFace API error: {error_msg}")
 
 class FreeChatService:
     def __init__(self, llm_provider: str, **kwargs):
@@ -74,10 +134,16 @@ class FreeChatService:
                 model=kwargs.get("model", "mixtral-8x7b-32768")
             )
         elif llm_provider == "huggingface":
+            api_key = kwargs.get("api_key")
+            if not api_key or api_key == "your_huggingface_token_here":
+                print("⚠️  No valid HuggingFace API key found. Using local model fallback...")
             self.llm = HuggingFaceLLM(
-                api_key=kwargs.get("api_key"),
+                api_key=api_key,
                 model=kwargs.get("model", "microsoft/DialoGPT-medium")
             )
+        elif llm_provider == "simple":
+            print("🚀 Using Simple LLM (no API key required)")
+            self.llm = NoAPILLM()
         else:
             raise ValueError(f"Unsupported LLM provider: {llm_provider}")
         

services/simple_llm.py

@@ -0,0 +1,199 @@
+"""
+Simple LLM service that works without API keys using basic text processing
+"""
+import re
+from typing import List, Dict
+
+class SimpleLLM:
+    """A basic LLM that provides helpful responses about code repositories without requiring API keys"""
+    
+    def __init__(self):
+        self.code_keywords = {
+            'python': ['def ', 'class ', 'import ', 'from ', '__init__', 'self.'],
+            'javascript': ['function', 'const ', 'let ', 'var ', 'async', 'await'],
+            'java': ['public class', 'private ', 'public ', 'static', 'void'],
+            'cpp': ['#include', 'int main', 'class ', 'namespace'],
+            'go': ['func ', 'package ', 'import', 'type'],
+            'rust': ['fn ', 'struct ', 'impl ', 'use ', 'mod '],
+        }
+    
+    def analyze_code_context(self, context: str) -> Dict:
+        """Analyze the code context to extract useful information"""
+        lines = context.split('\n')
+        
+        # Detect programming languages
+        languages = set()
+        for lang, keywords in self.code_keywords.items():
+            for keyword in keywords:
+                if keyword in context:
+                    languages.add(lang)
+        
+        # Extract file paths
+        file_paths = []
+        for line in lines:
+            if 'path' in line.lower() and ('/' in line or '\\' in line):
+                file_paths.append(line.strip())
+        
+        # Count functions and classes
+        functions = len(re.findall(r'\bdef\s+\w+|function\s+\w+|func\s+\w+', context))
+        classes = len(re.findall(r'\bclass\s+\w+', context))
+        
+        # Extract imports/dependencies
+        imports = re.findall(r'import\s+[\w.]+|from\s+[\w.]+\s+import|#include\s*<[\w.]+>', context)
+        
+        return {
+            'languages': list(languages),
+            'file_paths': file_paths[:5],  # Limit to 5 paths
+            'functions_count': functions,
+            'classes_count': classes,
+            'imports': imports[:10],  # Limit to 10 imports
+            'total_lines': len(lines)
+        }
+    
+    def generate_response(self, question: str, context: str) -> str:
+        """Generate a helpful response based on the question and code context"""
+        question_lower = question.lower()
+        analysis = self.analyze_code_context(context)
+        
+        # Question type detection and response generation
+        if any(word in question_lower for word in ['what', 'about', 'project', 'repository']):
+            return self._describe_project(analysis, context)
+        
+        elif any(word in question_lower for word in ['structure', 'organized', 'architecture']):
+            return self._describe_structure(analysis, context)
+        
+        elif any(word in question_lower for word in ['function', 'method', 'class']):
+            return self._describe_functions_classes(analysis, context)
+        
+        elif any(word in question_lower for word in ['dependency', 'dependencies', 'import', 'library']):
+            return self._describe_dependencies(analysis, context)
+        
+        elif any(word in question_lower for word in ['test', 'testing']):
+            return self._describe_tests(analysis, context)
+        
+        elif any(word in question_lower for word in ['error', 'exception', 'handling']):
+            return self._describe_error_handling(analysis, context)
+        
+        else:
+            return self._general_response(analysis, context)
+    
+    def _describe_project(self, analysis: Dict, context: str) -> str:
+        languages = ", ".join(analysis['languages']) if analysis['languages'] else "multiple languages"
+        
+        response = f"This project appears to be written in {languages}. "
+        
+        if analysis['classes_count'] > 0:
+            response += f"It contains {analysis['classes_count']} classes "
+        if analysis['functions_count'] > 0:
+            response += f"and {analysis['functions_count']} functions. "
+        
+        if 'api' in context.lower() or 'endpoint' in context.lower():
+            response += "It appears to be an API or web service. "
+        
+        if 'test' in context.lower():
+            response += "The project includes test files. "
+        
+        return response.strip()
+    
+    def _describe_structure(self, analysis: Dict, context: str) -> str:
+        response = "The code is organized with the following structure:\n\n"
+        
+        if analysis['file_paths']:
+            response += "**Key files/directories:**\n"
+            for path in analysis['file_paths']:
+                response += f"- {path}\n"
+            response += "\n"
+        
+        if analysis['languages']:
+            response += f"**Languages used:** {', '.join(analysis['languages'])}\n\n"
+        
+        if analysis['classes_count'] > 0:
+            response += f"**Classes found:** {analysis['classes_count']}\n"
+        if analysis['functions_count'] > 0:
+            response += f"**Functions found:** {analysis['functions_count']}\n"
+        
+        return response
+    
+    def _describe_functions_classes(self, analysis: Dict, context: str) -> str:
+        response = ""
+        
+        if analysis['classes_count'] > 0:
+            response += f"Found {analysis['classes_count']} classes in the codebase. "
+        
+        if analysis['functions_count'] > 0:
+            response += f"Found {analysis['functions_count']} functions/methods. "
+        
+        # Extract some actual function/class names from context
+        class_names = re.findall(r'class\s+(\w+)', context)
+        function_names = re.findall(r'def\s+(\w+)|function\s+(\w+)', context)
+        
+        if class_names:
+            response += f"\n\n**Some classes:** {', '.join(class_names[:5])}"
+        
+        if function_names:
+            func_list = [name for group in function_names for name in group if name]
+            response += f"\n\n**Some functions:** {', '.join(func_list[:5])}"
+        
+        return response if response else "No classes or functions clearly identified in the provided context."
+    
+    def _describe_dependencies(self, analysis: Dict, context: str) -> str:
+        if analysis['imports']:
+            response = "**Dependencies and imports found:**\n\n"
+            for imp in analysis['imports']:
+                response += f"- {imp}\n"
+            return response
+        else:
+            return "No clear dependencies or imports identified in the provided context."
+    
+    def _describe_tests(self, analysis: Dict, context: str) -> str:
+        if 'test' in context.lower():
+            return "Test files appear to be present in this codebase. Look for files with 'test' in their names or directories."
+        else:
+            return "No obvious test files identified in the provided context."
+    
+    def _describe_error_handling(self, analysis: Dict, context: str) -> str:
+        error_patterns = ['try:', 'except:', 'catch', 'throw', 'error', 'exception']
+        found_patterns = [pattern for pattern in error_patterns if pattern in context.lower()]
+        
+        if found_patterns:
+            return f"Error handling appears to be implemented using: {', '.join(found_patterns)}"
+        else:
+            return "No obvious error handling patterns identified in the provided context."
+    
+    def _general_response(self, analysis: Dict, context: str) -> str:
+        response = "Based on the code context provided:\n\n"
+        
+        if analysis['languages']:
+            response += f"- **Languages:** {', '.join(analysis['languages'])}\n"
+        
+        if analysis['total_lines'] > 0:
+            response += f"- **Code size:** {analysis['total_lines']} lines analyzed\n"
+        
+        if analysis['functions_count'] > 0:
+            response += f"- **Functions:** {analysis['functions_count']} found\n"
+        
+        if analysis['classes_count'] > 0:
+            response += f"- **Classes:** {analysis['classes_count']} found\n"
+        
+        response += "\nFor more specific information, please ask about particular aspects of the code."
+        
+        return response
+
+class NoAPILLM:
+    """Wrapper to use SimpleLLM with the same interface as other LLMs"""
+    
+    def __init__(self):
+        self.simple_llm = SimpleLLM()
+    
+    def __call__(self, prompt: str) -> str:
+        # Extract context and question from the prompt
+        if "Context from repository:" in prompt and "Question:" in prompt:
+            parts = prompt.split("Question:")
+            if len(parts) == 2:
+                context_part = parts[0].replace("Context from repository:", "").strip()
+                question_part = parts[1].replace("Answer:", "").strip()
+                
+                return self.simple_llm.generate_response(question_part, context_part)
+        
+        # Fallback for other prompt formats
+        return "I can help analyze code repositories. Please provide specific questions about the codebase structure, functions, dependencies, or other aspects of the code."