Add DeepSeek-V3

deepseek_client.py

@@ -0,0 +1,98 @@
+import os
+import time
+import requests
+from typing import List, Dict, Optional
+from config import Config
+
+class DeepseekClient:
+    def __init__(self):
+        self.api_key = Config.get_deepseek_key()
+        if not self.api_key:
+            raise ValueError("Deepseek API key is not set")
+        self.base_url = Config.DEEPSEEK_API_BASE
+        self.max_retries = 3
+        self.retry_delay = 2  # Initial delay in seconds
+
+    def create(self, messages: List[Dict[str, str]], model: str = None, response_format: Optional[Dict] = None) -> str:
+        if not self.api_key:
+            raise ValueError("Deepseek API key is not set")
+
+        retries = 0
+        last_error = None
+
+        while retries < self.max_retries:
+            try:
+                headers = {
+                    "Authorization": f"Bearer {self.api_key}",
+                    "HTTP-Referer": "https://replit.com",
+                    "X-Title": "MyChatMe",
+                    "Content-Type": "application/json"
+                }
+
+                data = {
+                    "model": model or Config.AUTO_MODEL,
+                    "messages": messages,
+                    "temperature": 0.7,
+                    "max_tokens": 1000
+                }
+
+                if response_format:
+                    data["response_format"] = response_format
+
+                response = requests.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=headers,
+                    json=data,
+                    timeout=30  # Added timeout
+                )
+
+                if response.status_code == 429:
+                    error_data = response.json()
+                    error_message = error_data.get('error', {}).get('message', 'Rate limit exceeded')
+                    print(f"Rate limit error: {error_message}")
+
+                    # Check if it's a provider-specific rate limit
+                    if 'metadata' in error_data.get('error', {}):
+                        provider = error_data['error']['metadata'].get('provider_name', 'Unknown')
+                        raise Exception(f"Rate limit exceeded for provider: {provider}")
+
+                    wait_time = self.retry_delay * (2 ** retries)
+                    print(f"Rate limit exceeded. Waiting {wait_time} seconds before retry...")
+                    time.sleep(wait_time)
+                    retries += 1
+                    continue
+
+                response.raise_for_status()
+                response_data = response.json()
+
+                if "error" in response_data:
+                    raise ValueError(f"Deepseek API returned error: {response_data['error']}")
+
+                if not response_data.get('choices'):
+                    raise ValueError("No choices in Deepseek API response")
+
+                if not response_data['choices'][0].get('message'):
+                    raise ValueError("No message in Deepseek API response choice")
+
+                return response_data['choices'][0]['message']['content']
+
+            except requests.exceptions.RequestException as e:
+                print(f"Deepseek Request Error: {str(e)}")
+                last_error = e
+                retries += 1
+                if retries < self.max_retries:
+                    time.sleep(self.retry_delay * (2 ** retries))
+            except ValueError as e:
+                print(f"Deepseek Value Error: {str(e)}")
+                last_error = e
+                break
+            except Exception as e:
+                print(f"Deepseek Unexpected Error: {str(e)}")
+                last_error = e
+                break
+
+        # If all retries failed or other error occurred
+        error_msg = str(last_error) if last_error else "Maximum retries exceeded"
+        if "Rate limit exceeded" in error_msg:
+            raise Exception(f"Deepseek rate limit exceeded. Please try again later or switch to a different model.")
+        raise Exception(f"Deepseek API error: {error_msg}")

llm_client.py

@@ -3,11 +3,13 @@ from typing import List, Dict
 import openai
 from config import Config
 from openrouter_client import OpenRouterClient
+from deepseek_client import DeepseekClient
 
 class LLMClient:
     def __init__(self):
         self.openai_client = None
         self.openrouter_client = None
+        self.deepseek_client = None
         self.test_mode = False  # For testing error scenarios
         self.initialize_clients()
 
@@ -16,11 +18,14 @@ class LLMClient:
         try:
             openai_key = Config.get_openai_key()
             openrouter_key = Config.get_openrouter_key()
+            deepseek_key = Config.get_deepseek_key()
 
             if openai_key:
                 self.openai_client = openai.OpenAI(api_key=openai_key)
             if openrouter_key:
                 self.openrouter_client = OpenRouterClient()
+            if deepseek_key:
+                self.deepseek_client = DeepseekClient()
         except Exception as e:
             print(f"Error initializing API clients: {str(e)}")
 
@@ -65,6 +70,29 @@ class LLMClient:
         except openai.APIError as e:
             raise Exception(f"OpenAI API error: {str(e)}")
 
+    def chat_deepseek(self, messages: List[Dict[str, str]]) -> str:
+        """Send chat completion request to Deepseek API"""
+        if not self.deepseek_client:
+            raise ValueError("Deepseek client not initialized. Please check your API key.")
+
+        if self.test_mode:
+            if messages and "test_error" in messages[-1].get("content", "").lower():
+                error_type = messages[-1]["content"].lower()
+                if "api_key" in error_type:
+                    raise ValueError("Invalid API key")
+                elif "rate_limit" in error_type:
+                    raise Exception("Rate limit exceeded")
+                elif "network" in error_type:
+                    raise Exception("Network connection error")
+
+        try:
+            return self.deepseek_client.create(
+                messages=messages,
+                model=Config.DEEPSEEK_MODEL
+            )
+        except Exception as e:
+            raise Exception(f"Deepseek API error: {str(e)}")
+
     def chat_claude(self, messages: List[Dict[str, str]]) -> str:
         """Send chat completion request to Claude via OpenRouter"""
         if not self.openrouter_client:
@@ -118,4 +146,4 @@ class LLMClient:
             return response.choices[0].message.content
         except Exception as e:
             print(f"Failed to generate context summary: {str(e)}")
-            return ""  # Return empty string if summarization fails
+            return ""  # Return empty string if summarization fails

main.py

@@ -208,7 +208,8 @@ def main():
                 "OpenRouter-Auto": llm_client.chat_auto,
                 "OpenAI": llm_client.chat_openai,
                 "Claude-3.5": llm_client.chat_claude,
-                "Gemini-2.0": llm_client.chat_gemini
+                "Gemini-2.0": llm_client.chat_gemini,
+                "DeepSeek-V3": llm_client.chat_deepseek
             }
 
             if model in model_map:
@@ -259,4 +260,4 @@ def main():
         st.rerun()
 
 if __name__ == "__main__":
-    main()
+    main()

ui_components.py

@@ -52,7 +52,7 @@ def render_sidebar(i18n, chat_manager):
         # Model selection - デフォルトをOpenRouter-Autoに設定
         model = st.selectbox(
             i18n.get_text("model_selection"),
-            ["OpenRouter-Auto", "OpenAI", "Claude-3.5", "Gemini-2.0"],
+            ["OpenRouter-Auto", "OpenAI", "Claude-3.5", "Gemini-2.0", "DeepSeek-V3"],
             index=0,
             key="model_selection"
         )
@@ -87,4 +87,4 @@ def render_sidebar(i18n, chat_manager):
             except Exception as e:
                 show_notification(f"{i18n.get_text('export_error')}: {str(e)}", "error")
 
-        return language, model
+        return language, model