Create multi_llm_provider.py

multi_llm_provider.py

@@ -0,0 +1,361 @@
+import streamlit as st
+import os
+import json
+import anthropic
+import requests
+from typing import Dict, Any, List, Optional
+
+# Initialize the environment variables for different providers
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_API_KEY")
+
+class AIProviderManager:
+    """Manager for multiple AI providers"""
+    
+    def __init__(self):
+        self.providers = {}
+        self.initialize_providers()
+    
+    def initialize_providers(self):
+        """Initialize available AI providers"""
+        # Initialize Anthropic (Claude)
+        if ANTHROPIC_API_KEY:
+            try:
+                self.providers["claude"] = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+                st.sidebar.success("🟢 Claude AI connected")
+            except Exception as e:
+                st.sidebar.error(f"🔴 Error initializing Claude: {str(e)}")
+        
+        # Initialize OpenAI if available
+        if OPENAI_API_KEY:
+            try:
+                import openai
+                openai.api_key = OPENAI_API_KEY
+                self.providers["openai"] = True
+                st.sidebar.success("🟢 OpenAI connected")
+            except ImportError:
+                st.sidebar.warning("⚠️ OpenAI SDK not installed. Run 'pip install openai'")
+            except Exception as e:
+                st.sidebar.error(f"🔴 Error initializing OpenAI: {str(e)}")
+        
+        # Initialize DeepSeek if available
+        if DEEPSEEK_API_KEY:
+            try:
+                import openai as deepseek_client
+                self.providers["deepseek"] = {
+                    "client": deepseek_client,
+                    "base_url": "https://api.deepseek.com"
+                }
+                st.sidebar.success("🟢 DeepSeek AI connected")
+            except ImportError:
+                st.sidebar.warning("⚠️ OpenAI SDK needed for DeepSeek. Run 'pip install openai'")
+            except Exception as e:
+                st.sidebar.error(f"🔴 Error initializing DeepSeek: {str(e)}")
+        
+        # Initialize Perplexity if available
+        if PERPLEXITY_API_KEY:
+            self.providers["perplexity"] = True
+            st.sidebar.success("🟢 Perplexity API connected")
+    
+    def get_available_models(self):
+        """Get all available models across providers"""
+        models = {}
+        
+        # Claude models
+        if "claude" in self.providers:
+            models.update({
+                "claude-3-sonnet-20250219": "Claude 3 Sonnet",
+                "claude-3-haiku-20250319": "Claude 3 Haiku",
+                "claude-3-opus-20250229": "Claude 3 Opus"
+            })
+        
+        # OpenAI models
+        if "openai" in self.providers:
+            models.update({
+                "gpt-4": "GPT-4",
+                "gpt-4-turbo": "GPT-4 Turbo",
+                "gpt-3.5-turbo": "GPT-3.5 Turbo"
+            })
+        
+        # DeepSeek models
+        if "deepseek" in self.providers:
+            models.update({
+                "deepseek-chat": "DeepSeek Chat",
+                "deepseek-coder": "DeepSeek Coder"
+            })
+        
+        return models
+    
+    def generate_text(self, prompt: str, model: str, system_prompt: str = None, temperature: float = 0.7, max_tokens: int = 1000):
+        """Generate text using the specified model"""
+        # Check if the specified model is available
+        if model.startswith("claude") and "claude" in self.providers:
+            return self._generate_with_claude(prompt, model, system_prompt, temperature, max_tokens)
+        
+        elif model.startswith("gpt") and "openai" in self.providers:
+            return self._generate_with_openai(prompt, model, system_prompt, temperature, max_tokens)
+        
+        elif model.startswith("deepseek") and "deepseek" in self.providers:
+            return self._generate_with_deepseek(prompt, model, system_prompt, temperature, max_tokens)
+        
+        else:
+            # Fallback to Claude if available
+            if "claude" in self.providers:
+                st.warning(f"Model {model} not available. Falling back to Claude 3 Sonnet.")
+                return self._generate_with_claude(
+                    prompt, 
+                    "claude-3-sonnet-20250219", 
+                    system_prompt, 
+                    temperature, 
+                    max_tokens
+                )
+            else:
+                raise ValueError(f"No AI provider available for model: {model}")
+    
+    def _generate_with_claude(self, prompt: str, model: str, system_prompt: str = None, temperature: float = 0.7, max_tokens: int = 1000):
+        """Generate text using Claude"""
+        client = self.providers["claude"]
+        
+        messages = [{"role": "user", "content": prompt}]
+        
+        response = client.messages.create(
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            system=system_prompt if system_prompt else "You are a helpful assistant.",
+            messages=messages
+        )
+        
+        return response.content[0].text
+    
+    def _generate_with_openai(self, prompt: str, model: str, system_prompt: str = None, temperature: float = 0.7, max_tokens: int = 1000):
+        """Generate text using OpenAI"""
+        import openai
+        
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        messages.append({"role": "user", "content": prompt})
+        
+        response = openai.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens
+        )
+        
+        return response.choices[0].message.content
+    
+    def _generate_with_deepseek(self, prompt: str, model: str, system_prompt: str = None, temperature: float = 0.7, max_tokens: int = 1000):
+        """Generate text using DeepSeek"""
+        import openai as deepseek
+        
+        deepseek.api_key = DEEPSEEK_API_KEY
+        deepseek.base_url = "https://api.deepseek.com"
+        
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        messages.append({"role": "user", "content": prompt})
+        
+        response = deepseek.chat.completions.create(
+            model="deepseek-chat" if model == "deepseek-chat" else "deepseek-coder",
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens
+        )
+        
+        return response.choices[0].message.content
+    
+    def web_search(self, query: str) -> List[Dict[str, Any]]:
+        """Perform a web search using Perplexity API"""
+        if "perplexity" not in self.providers or not PERPLEXITY_API_KEY:
+            raise ValueError("Perplexity API not available")
+        
+        headers = {
+            "Authorization": f"Bearer {PERPLEXITY_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "query": query,
+            "max_results": 5
+        }
+        
+        try:
+            response = requests.post(
+                "https://api.perplexity.ai/search",
+                headers=headers,
+                json=data
+            )
+            
+            if response.status_code == 200:
+                results = response.json()
+                return results.get("results", [])
+            else:
+                st.error(f"Error in web search: {response.status_code} - {response.text}")
+                return []
+        except Exception as e:
+            st.error(f"Error performing web search: {str(e)}")
+            return []
+    
+    def enhance_with_web_search(self, slide_content: Dict[str, Any], search_query: str = None) -> Dict[str, Any]:
+        """Enhance slide content with web search results"""
+        if "perplexity" not in self.providers or not PERPLEXITY_API_KEY:
+            st.warning("Web search enhancement not available (Perplexity API key required)")
+            return slide_content
+        
+        # Use slide title if no search query provided
+        if not search_query:
+            title = slide_content.get("title", "")
+            search_query = f"latest information about {title}"
+        
+        try:
+            with st.spinner(f"Searching the web for: {search_query}"):
+                results = self.web_search(search_query)
+                
+                if not results:
+                    st.warning("No search results found")
+                    return slide_content
+                
+                # Compile search results
+                search_content = "Web search results:\n\n"
+                for i, result in enumerate(results, 1):
+                    title = result.get("title", "No title")
+                    snippet = result.get("snippet", "No snippet")
+                    url = result.get("url", "No URL")
+                    
+                    search_content += f"{i}. {title}\n"
+                    search_content += f"   {snippet}\n"
+                    search_content += f"   Source: {url}\n\n"
+                
+                # Create an enrichment prompt
+                prompt = f"""
+                You are an expert presentation content creator.
+                
+                Current slide:
+                Title: {slide_content.get('title', 'No title')}
+                Content: {slide_content.get('content', [])}
+                
+                I have gathered recent information about this topic. Please use this information to enhance the slide content:
+                
+                {search_content}
+                
+                Please provide:
+                1. An updated slide title (if needed)
+                2. Enhanced content points that incorporate the latest information
+                3. A note about the sources of this information
+                
+                Return your response as JSON with the following structure:
+                {{
+                  "title": "Enhanced title",
+                  "content": ["Point 1", "Point 2", "Point 3"],
+                  "notes": "Notes including source information"
+                }}
+                """
+                
+                # Generate enhanced content
+                response = self.generate_text(
+                    prompt=prompt,
+                    model="claude-3-sonnet-20250219" if "claude" in self.providers else "gpt-4" if "openai" in self.providers else "deepseek-chat",
+                    system_prompt="You are an expert at enhancing presentation content with the latest information. Always respond with valid JSON.",
+                    temperature=0.5,
+                    max_tokens=2000
+                )
+                
+                # Extract the JSON from the response
+                try:
+                    # Find JSON in the text
+                    json_start = response.find("{")
+                    json_end = response.rfind("}") + 1
+                    
+                    if json_start >= 0 and json_end > 0:
+                        json_str = response[json_start:json_end]
+                        enhanced_content = json.loads(json_str)
+                        
+                        # Update the slide content
+                        slide_content["title"] = enhanced_content.get("title", slide_content.get("title", ""))
+                        slide_content["content"] = enhanced_content.get("content", slide_content.get("content", []))
+                        
+                        # Append to existing notes
+                        existing_notes = slide_content.get("notes", "")
+                        new_notes = enhanced_content.get("notes", "")
+                        slide_content["notes"] = f"{existing_notes}\n\n{new_notes}".strip()
+                        
+                        # Add source information
+                        slide_content["source_info"] = {
+                            "search_query": search_query,
+                            "results_count": len(results),
+                            "timestamp": "March 2025"
+                        }
+                        
+                        st.success("Slide enhanced with latest web information!")
+                    else:
+                        st.error("Could not extract JSON from AI response")
+                except Exception as e:
+                    st.error(f"Error processing AI response: {str(e)}")
+        
+        except Exception as e:
+            st.error(f"Error enhancing content with web search: {str(e)}")
+        
+        return slide_content
+    
+    def generate_image_description(self, slide_content: Dict[str, Any]) -> str:
+        """Generate an optimized description for image generation"""
+        if not "claude" in self.providers and not "openai" in self.providers:
+            return ""
+        
+        title = slide_content.get('title', '')
+        
+        if isinstance(slide_content.get('content', []), list):
+            content_text = " ".join(slide_content.get('content', []))[:500]  # Limit length
+        else:
+            content_text = str(slide_content.get('content', ''))[:500]
+        
+        prompt = f"""
+        You are an expert at creating image generation prompts.
+        
+        I need a detailed visual description for a presentation slide with the following content:
+        
+        Title: {title}
+        Content: {content_text}
+        
+        Please create a detailed description (under a single paragraph of 50 words or less) that would help an AI image generator create an appropriate, professional, metaphorical image for this slide.
+        
+        Focus on imagery that would work well in a business presentation context - prefer abstract, conceptual, or metaphorical imagery over literal representations.
+        Specify style (photorealistic, illustration, 3D render), color scheme, and composition.
+        
+        ONLY provide the description itself with no explanations, introductions, or extra text.
+        """
+        
+        try:
+            # Choose the model based on availability
+            model = "claude-3-haiku-20250319" if "claude" in self.providers else "gpt-3.5-turbo"
+            
+            response = self.generate_text(
+                prompt=prompt,
+                model=model,
+                system_prompt="You are an expert at creating image generation prompts for business presentations.",
+                temperature=0.7,
+                max_tokens=200
+            )
+            
+            # Clean up the response
+            description = response.strip()
+            
+            return description
+        except Exception as e:
+            st.error(f"Error generating image description: {str(e)}")
+            return f"An image representing {title}"
+
+# Initialize the AI provider manager
+def get_ai_manager():
+    """Get or create the AI provider manager"""
+    if 'ai_manager' not in st.session_state:
+        st.session_state.ai_manager = AIProviderManager()
+    
+    return st.session_state.ai_manager