import logging import httpx import asyncio from typing import Dict, Any, List, Union, Optional from fastapi import HTTPException from modules.shared.configuration import APP_CONFIG from modules.aicore.aicoreBase import BaseConnectorAi from modules.datamodels.datamodelAi import AiModel, ModelCapabilitiesEnum, PriorityEnum, ProcessingModeEnum, OperationTypeEnum, AiModelCall, AiModelResponse # Configure logger logger = logging.getLogger(__name__) def loadConfigData(): """Load configuration data for Perplexity connector""" return { "apiKey": APP_CONFIG.get('Connector_AiPerplexity_API_SECRET'), "apiUrl": APP_CONFIG.get('Connector_AiPerplexity_API_URL'), "modelName": APP_CONFIG.get('Connector_AiPerplexity_MODEL_NAME'), "temperature": float(APP_CONFIG.get('Connector_AiPerplexity_TEMPERATURE')), } class AiPerplexity(BaseConnectorAi): """Connector for communication with the Perplexity API.""" def __init__(self): super().__init__() # Load configuration self.config = loadConfigData() self.apiKey = self.config["apiKey"] self.apiUrl = self.config["apiUrl"] self.modelName = self.config["modelName"] # HttpClient for API calls self.httpClient = httpx.AsyncClient( timeout=120.0, # Longer timeout for complex requests headers={ "Authorization": f"Bearer {self.apiKey}", "Content-Type": "application/json", "Accept": "application/json" } ) logger.info(f"Perplexity Connector initialized with model: {self.modelName}") def getConnectorType(self) -> str: """Get the connector type identifier.""" return "perplexity" def getModels(self) -> List[AiModel]: """Get all available Perplexity models.""" return [ AiModel( name="perplexity_callAiBasic", displayName="Llama 3.1 Sonar Large 128k", connectorType="perplexity", maxTokens=128000, contextLength=128000, costPer1kTokensInput=0.005, costPer1kTokensOutput=0.005, speedRating=8, qualityRating=8, capabilities=[ModelCapabilitiesEnum.TEXT_GENERATION, ModelCapabilitiesEnum.CHAT, ModelCapabilitiesEnum.REASONING, ModelCapabilitiesEnum.WEB_SEARCH], functionCall=self.callAiBasic, priority=PriorityEnum.BALANCED, processingMode=ProcessingModeEnum.ADVANCED, operationTypes=[OperationTypeEnum.GENERAL, OperationTypeEnum.PLAN, OperationTypeEnum.ANALYSE, OperationTypeEnum.GENERATE, OperationTypeEnum.WEB_RESEARCH], version="llama-3.1-sonar-large-128k-online", calculatePriceUsd=lambda processingTime, bytesSent, bytesReceived: (bytesSent / 4 / 1000) * 0.005 + (bytesReceived / 4 / 1000) * 0.005 ), AiModel( name="perplexity_callAiWithWebSearch", displayName="Sonar Pro", connectorType="perplexity", maxTokens=128000, contextLength=128000, costPer1kTokensInput=0.01, costPer1kTokensOutput=0.01, speedRating=7, qualityRating=9, capabilities=[ModelCapabilitiesEnum.TEXT_GENERATION, ModelCapabilitiesEnum.WEB_SEARCH, ModelCapabilitiesEnum.RESEARCH], functionCall=self.callAiWithWebSearch, priority=PriorityEnum.QUALITY, processingMode=ProcessingModeEnum.DETAILED, operationTypes=[OperationTypeEnum.WEB_RESEARCH], version="sonar-pro", calculatePriceUsd=lambda processingTime, bytesSent, bytesReceived: (bytesSent / 4 / 1000) * 0.01 + (bytesReceived / 4 / 1000) * 0.01 ), AiModel( name="perplexity_researchTopic", displayName="Mistral 7B Instruct", connectorType="perplexity", maxTokens=32000, contextLength=32000, costPer1kTokensInput=0.002, costPer1kTokensOutput=0.002, speedRating=8, qualityRating=8, capabilities=[ModelCapabilitiesEnum.WEB_SEARCH, ModelCapabilitiesEnum.RESEARCH, ModelCapabilitiesEnum.INFORMATION_GATHERING], functionCall=self.researchTopic, priority=PriorityEnum.COST, processingMode=ProcessingModeEnum.BASIC, operationTypes=[OperationTypeEnum.WEB_RESEARCH], version="mistral-7b-instruct", calculatePriceUsd=lambda processingTime, bytesSent, bytesReceived: (bytesSent / 4 / 1000) * 0.002 + (bytesReceived / 4 / 1000) * 0.002 ), AiModel( name="perplexity_answerQuestion", displayName="Mistral 7B Instruct QA", connectorType="perplexity", maxTokens=32000, contextLength=32000, costPer1kTokensInput=0.002, costPer1kTokensOutput=0.002, speedRating=8, qualityRating=8, capabilities=[ModelCapabilitiesEnum.WEB_SEARCH, ModelCapabilitiesEnum.QUESTION_ANSWERING, ModelCapabilitiesEnum.RESEARCH], functionCall=self.answerQuestion, priority=PriorityEnum.COST, processingMode=ProcessingModeEnum.BASIC, operationTypes=[OperationTypeEnum.WEB_RESEARCH], version="mistral-7b-instruct", calculatePriceUsd=lambda processingTime, bytesSent, bytesReceived: (bytesSent / 4 / 1000) * 0.002 + (bytesReceived / 4 / 1000) * 0.002 ), AiModel( name="perplexity_getCurrentNews", displayName="Mistral 7B Instruct News", connectorType="perplexity", maxTokens=32000, contextLength=32000, costPer1kTokensInput=0.002, costPer1kTokensOutput=0.002, speedRating=8, qualityRating=8, capabilities=[ModelCapabilitiesEnum.WEB_SEARCH, ModelCapabilitiesEnum.NEWS, ModelCapabilitiesEnum.CURRENT_EVENTS], functionCall=self.getCurrentNews, priority=PriorityEnum.COST, processingMode=ProcessingModeEnum.BASIC, operationTypes=[OperationTypeEnum.WEB_RESEARCH], version="mistral-7b-instruct", calculatePriceUsd=lambda processingTime, bytesSent, bytesReceived: (bytesSent / 4 / 1000) * 0.002 + (bytesReceived / 4 / 1000) * 0.002 ) ] async def callAiBasic(self, modelCall: AiModelCall) -> AiModelResponse: """ Calls the Perplexity API with the given messages using standardized pattern. Args: modelCall: AiModelCall with messages and options Returns: AiModelResponse with content and metadata Raises: HTTPException: For errors in API communication """ try: # Extract parameters from modelCall messages = modelCall.messages model = modelCall.model options = modelCall.options temperature = options.get("temperature", self.config.get("temperature", 0.2)) maxTokens = model.maxTokens payload = { "model": self.modelName, "messages": messages, "temperature": temperature, "max_tokens": maxTokens } response = await self.httpClient.post( self.apiUrl, json=payload ) if response.status_code != 200: error_detail = f"Perplexity API error: {response.status_code} - {response.text}" logger.error(error_detail) # Provide more specific error messages based on status code if response.status_code == 429: error_message = "Rate limit exceeded. Please wait before making another request." elif response.status_code == 401: error_message = "Invalid API key. Please check your Perplexity API configuration." elif response.status_code == 400: error_message = f"Invalid request to Perplexity API: {response.text}" else: error_message = f"Perplexity API error ({response.status_code}): {response.text}" raise HTTPException(status_code=500, detail=error_message) responseJson = response.json() content = responseJson["choices"][0]["message"]["content"] return AiModelResponse( content=content, success=True, modelId=self.modelName, metadata={"response_id": responseJson.get("id", "")} ) except Exception as e: logger.error(f"Error calling Perplexity API: {str(e)}") raise HTTPException(status_code=500, detail=f"Error calling Perplexity API: {str(e)}") async def callAiWithWebSearch(self, query: str, temperature: float = None, maxTokens: int = None) -> str: """ Calls Perplexity API with web search capabilities for research. Args: query: The research query or question temperature: Temperature for response generation (0.0-1.0) maxTokens: Maximum number of tokens in the response Returns: The response from Perplexity with web search context """ try: # Use parameters from configuration if none were overridden if temperature is None: temperature = self.config.get("temperature", 0.2) # Don't set maxTokens from config - let the model use its full context length # Our continuation system handles stopping early via prompt engineering # For web search, we use the configured model name webSearchModel = self.modelName payload = { "model": webSearchModel, "messages": [ { "role": "user", "content": query } ], "temperature": temperature } # Add max_tokens - use provided value or throw error if maxTokens is None: raise ValueError("maxTokens must be provided for Perplexity API calls") payload["max_tokens"] = maxTokens response = await self.httpClient.post( self.apiUrl, json=payload ) if response.status_code != 200: error_detail = f"Perplexity Web Search API error: {response.status_code} - {response.text}" logger.error(error_detail) if response.status_code == 429: error_message = "Rate limit exceeded for web search. Please wait before making another request." elif response.status_code == 401: error_message = "Invalid API key for web search. Please check your Perplexity API configuration." elif response.status_code == 400: error_message = f"Invalid request to Perplexity Web Search API: {response.text}" else: error_message = f"Perplexity Web Search API error ({response.status_code}): {response.text}" raise HTTPException(status_code=500, detail=error_message) responseJson = response.json() content = responseJson["choices"][0]["message"]["content"] return content except Exception as e: logger.error(f"Error calling Perplexity Web Search API: {str(e)}") raise HTTPException(status_code=500, detail=f"Error calling Perplexity Web Search API: {str(e)}") async def researchTopic(self, topic: str, depth: str = "basic") -> str: """ Research a topic using Perplexity's web search capabilities. Args: topic: The topic to research depth: Research depth - "basic", "detailed", or "comprehensive" Returns: Comprehensive research results on the topic """ try: # Create research prompts based on depth if depth == "basic": prompt = f"Provide a basic overview of: {topic}" elif depth == "detailed": prompt = f"Provide a detailed analysis of: {topic}. Include recent developments, key facts, and important information." else: # comprehensive prompt = f"Provide a comprehensive research report on: {topic}. Include recent developments, key facts, statistics, expert opinions, and current trends." return await self.callAiWithWebSearch(prompt) except Exception as e: logger.error(f"Error researching topic: {str(e)}") raise HTTPException(status_code=500, detail=f"Error researching topic: {str(e)}") async def answerQuestion(self, question: str, context: str = None) -> str: """ Answer a question using web search for current information. Args: question: The question to answer context: Optional context to provide Returns: Answer with web search context """ try: if context: prompt = f"Context: {context}\n\nQuestion: {question}\n\nPlease provide a comprehensive answer using current information from the web." else: prompt = f"Question: {question}\n\nPlease provide a comprehensive answer using current information from the web." return await self.callAiWithWebSearch(prompt) except Exception as e: logger.error(f"Error answering question: {str(e)}") raise HTTPException(status_code=500, detail=f"Error answering question: {str(e)}") async def getCurrentNews(self, topic: str = None, limit: int = 5) -> str: """ Get current news on a specific topic. Args: topic: The topic to get news about (optional) limit: Number of news items to retrieve Returns: Current news information """ try: if topic: prompt = f"Get the latest news about {topic}. Provide {limit} recent news items with sources and dates." else: prompt = f"Get the latest news. Provide {limit} recent news items with sources and dates." return await self.callAiWithWebSearch(prompt) except Exception as e: logger.error(f"Error getting current news: {str(e)}") raise HTTPException(status_code=500, detail=f"Error getting current news: {str(e)}") async def _testConnection(self) -> bool: """ Tests the connection to the Perplexity API. Returns: True if connection is successful, False otherwise """ try: # Try a simple test message testMessages = [ {"role": "user", "content": "Hello, please respond with just 'OK' to confirm the connection works."} ] response = await self.callAiBasic(testMessages) return response and len(response.strip()) > 0 except Exception as e: logger.error(f"Perplexity connection test failed: {str(e)}") return False