Update utils_core/llm_utils.py

utils_core/llm_utils.py

@@ -1,285 +1,111 @@
-"""
-LLM API Utility Functions
-
-This module provides utility functions for interacting with LLM APIs,
-particularly Claude API, and processing responses.
-"""
-
 import os
-import json
-import re
-from typing import Dict, List, Any, Optional, Union, Tuple
+import logging
+import traceback
 import requests
-import anthropic
-from langchain_anthropic import ChatAnthropic
+from typing import Tuple, Optional
 
-def call_claude_api(
-    prompt: str,
-    system_prompt: Optional[str] = None,
-    temperature: float = 0.0,
-    max_tokens: int = 4000,
-    model: str = "claude-3-7-sonnet-20250219"
-) -> str:
-    """
-    Call the Claude API directly using the Anthropic Python client
-    
-    Parameters:
-    -----------
-    prompt : str
-        The human prompt to send to Claude
-    system_prompt : str, optional
-        System prompt for Claude
-    temperature : float
-        Temperature setting (0.0 = deterministic, 1.0 = creative)
-    max_tokens : int
-        Maximum tokens in the response
-    model : str
-        Claude model to use
-        
-    Returns:
-    --------
-    str
-        Claude's response text
-    """
-    # Get API key from environment
-    api_key = os.getenv("ANTHROPIC_API_KEY")
-    if not api_key:
-        raise ValueError("ANTHROPIC_API_KEY environment variable not set")
-    
-    # Initialize client
-    client = anthropic.Anthropic(api_key=api_key)
-    
-    # Create messages
-    messages = []
-    if system_prompt:
-        messages.append({"role": "system", "content": system_prompt})
-    
-    messages.append({"role": "user", "content": prompt})
-    
-    # Call API
-    response = client.messages.create(
-        model=model,
-        messages=messages,
-        max_tokens=max_tokens,
-        temperature=temperature
-    )
-    
-    # Return content
-    return response.content[0].text
+# Configure logging
+logging.basicConfig(level=logging.DEBUG, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("llm_connectivity")
 
-def create_claude_client(
-    model: str = "claude-3-haiku-20240307",
-    temperature: float = 0.0,
-    anthropic_api_key: Optional[str] = None
-) -> ChatAnthropic:
+def comprehensive_anthropic_connectivity_test() -> Tuple[bool, Optional[str]]:
     """
-    Create a LangChain ChatAnthropic client
+    Perform a comprehensive connectivity test for Anthropic API
     
-    Parameters:
-    -----------
-    model : str
-        Claude model to use
-    temperature : float
-        Temperature setting (0.0 = deterministic, 1.0 = creative)
-    anthropic_api_key : str, optional
-        API key (will use environment variable if not provided)
-        
     Returns:
-    --------
-    ChatAnthropic
-        Configured LangChain ChatAnthropic client
-    """
-    # Get API key from environment if not provided
-    api_key = anthropic_api_key or os.getenv("ANTHROPIC_API_KEY")
-    if not api_key:
-        raise ValueError("ANTHROPIC_API_KEY environment variable not set")
-    
-    # Create LangChain client
-    client = ChatAnthropic(
-        model=model,
-        anthropic_api_key=api_key,
-        temperature=temperature
-    )
-    
-    return client
-
-def extract_json(text: str) -> Dict[str, Any]:
-    """
-    Extract JSON from text that might contain additional content
-    
-    Parameters:
-    -----------
-    text : str
-        Text that may contain JSON
-        
-    Returns:
-    --------
-    dict
-        Extracted JSON as a dictionary
-        
-    Raises:
-    -------
-    ValueError
-        If no valid JSON can be extracted
+    - Boolean indicating success
+    - Error message (if any)
     """
     try:
-        # First, try to parse the entire text as JSON
-        return json.loads(text)
-    except json.JSONDecodeError:
-        # If that fails, look for JSON block
-        json_pattern = r'```json\s*([\s\S]*?)\s*```'
-        match = re.search(json_pattern, text, re.DOTALL)
-        if match:
-            try:
-                return json.loads(match.group(1))
-            except json.JSONDecodeError:
-                pass
-        
-        # Try a more aggressive approach to find JSON-like content
-        json_pattern = r'({[\s\S]*})'
-        match = re.search(json_pattern, text)
-        if match:
-            try:
-                return json.loads(match.group(1))
-            except json.JSONDecodeError:
-                pass
+        # 1. Check API Key
+        api_key = os.getenv("ANTHROPIC_API_KEY")
+        if not api_key:
+            return False, "No Anthropic API key found in environment variables"
         
-        raise ValueError(f"Could not extract JSON from response: {text}")
-
-def extract_code(text: str, language: str = None) -> str:
-    """
-    Extract code block from text
-    
-    Parameters:
-    -----------
-    text : str
-        Text that may contain code blocks
-    language : str, optional
-        Specific language to extract (e.g., 'python', 'sql')
+        # 2. Test network connectivity to Anthropic
+        try:
+            # Check basic internet connectivity
+            requests.get("https://www.google.com", timeout=5)
+        except requests.RequestException:
+            return False, "No internet connection detected"
         
-    Returns:
-    --------
-    str
-        Extracted code as a string
+        # 3. Test Anthropic API endpoint
+        try:
+            import anthropic
+            
+            # Create client
+            client = anthropic.Anthropic(api_key=api_key)
+            
+            # Attempt a simple API call
+            response = client.messages.create(
+                model="claude-3-haiku-20240307",
+                max_tokens=10,
+                messages=[
+                    {"role": "user", "content": "Confirm API connectivity"}
+                ]
+            )
+            
+            # Check response
+            if not response or not response.content:
+                return False, "Received empty response from Anthropic API"
+            
+            logger.info("Anthropic API connectivity test successful")
+            return True, None
         
-    Raises:
-    -------
-    ValueError
-        If no valid code block can be extracted
-    """
-    # Try to extract code with specific language
-    if language:
-        pattern = rf'```{language}\s*(.*?)\s*```'
-        match = re.search(pattern, text, re.DOTALL)
-        if match:
-            return match.group(1).strip()
-    
-    # Try to extract code from any language block
-    match = re.search(r'```(\w*)\s*(.*?)\s*```', text, re.DOTALL)
-    if match:
-        return match.group(2).strip()
-    
-    # If no code blocks, look for indented text
-    lines = text.split('\n')
-    indented_lines = []
-    in_indented_block = False
-    
-    for line in lines:
-        if line.startswith('    ') or line.startswith('\t'):
-            indented_lines.append(line.replace('    ', '', 1) if line.startswith('    ') else line.replace('\t', '', 1))
-            in_indented_block = True
-        elif line.strip() == '' and in_indented_block:
-            indented_lines.append('')
-        elif in_indented_block:
-            break
-    
-    if indented_lines:
-        return '\n'.join(indented_lines).strip()
-    
-    # If all else fails, return empty string
-    return ""
+        except Exception as api_error:
+            logger.error(f"Anthropic API connection failed: {api_error}")
+            return False, f"Anthropic API connection error: {str(api_error)}"
+    
+    except Exception as e:
+        logger.error(f"Unexpected error in connectivity test: {e}")
+        logger.error(traceback.format_exc())
+        return False, f"Unexpected error: {str(e)}"
 
-def summarize_code(code: str, language: str = "python") -> str:
+def debug_anthropic_connection():
     """
-    Generate a summary of code using Claude
+    Comprehensive debug function for Anthropic API connection
     
-    Parameters:
-    -----------
-    code : str
-        The code to summarize
-    language : str
-        The programming language
-        
-    Returns:
-    --------
-    str
-        Summary of the code
+    Prints detailed diagnostic information
     """
-    system_prompt = """You are an expert code analyzer. Your task is to provide a concise summary of the provided code, 
-    explaining what it does, its key components, and any important patterns or techniques used."""
+    print("🔍 Anthropic API Connectivity Diagnostics")
+    print("=" * 50)
     
-    prompt = f"""Please provide a brief summary of this {language} code:
-
-```{language}
-{code}
-```
-
-Focus on:
-1. The main purpose of the code
-2. Key functions/classes and what they do
-3. Any notable algorithms or design patterns used
-4. Potential use cases
-
-Keep your response under 150 words."""
-    
-    return call_claude_api(prompt, system_prompt=system_prompt, max_tokens=500)
-
-def generate_unit_tests(code: str, language: str = "python") -> str:
-    """
-    Generate unit tests for code using Claude
+    # 1. Environment Check
+    print("\n📋 Environment Variables:")
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    print(f"ANTHROPIC_API_KEY: {'SET' if api_key else 'NOT SET'}")
     
-    Parameters:
-    -----------
-    code : str
-        The code to generate tests for
-    language : str
-        The programming language
-        
-    Returns:
-    --------
-    str
-        Generated unit tests
-    """
-    system_prompt = """You are an expert at writing unit tests. Your task is to create comprehensive unit tests 
-    for the provided code, ensuring good test coverage and following best practices."""
+    # 2. Connectivity Test
+    print("\n🌐 Connectivity Test:")
+    success, error = comprehensive_anthropic_connectivity_test()
     
-    prompt = f"""Please generate unit tests for this {language} code:
-
-```{language}
-{code}
-```
-
-Please include:
-1. Test cases for normal operation
-2. Test cases for edge cases and potential errors
-3. Use appropriate mocking where needed
-4. Follow best practices for {language} unit testing
-
-Return ONLY the test code without explanation."""
+    if success:
+        print("✅ API Connection: Successful")
+    else:
+        print(f"❌ API Connection: Failed")
+        print(f"Error Details: {error}")
     
-    return call_claude_api(prompt, system_prompt=system_prompt, max_tokens=2000)
+    # 3. Library Versions
+    print("\n📦 Library Versions:")
+    try:
+        import anthropic
+        import langchain
+        print(f"Anthropic Library: {anthropic.__version__}")
+        print(f"LangChain Library: {langchain.__version__}")
+    except ImportError as e:
+        print(f"Error checking library versions: {e}")
+    
+    # 4. Network Diagnostics
+    print("\n🔬 Network Diagnostics:")
+    try:
+        import socket
+        print("Hostname:", socket.gethostname())
+        print("IP Addresses:")
+        print(socket.gethostbyname(socket.gethostname()))
+    except Exception as e:
+        print(f"Network diagnostic error: {e}")
 
-# Example usage
+# Run diagnostics if script is executed directly
 if __name__ == "__main__":
-    # Test if API key is available
-    api_key = os.getenv("ANTHROPIC_API_KEY")
-    if not api_key:
-        print("Warning: ANTHROPIC_API_KEY environment variable not set")
-    else:
-        # Test API call
-        response = call_claude_api(
-            "Write a one-sentence explanation of what an LLM is.",
-            temperature=0.0,
-            max_tokens=100
-        )
-        print(f"Claude API response: {response}")
+    debug_anthropic_connection()