semantio 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

semantio/agent.py

@@ -20,31 +20,35 @@ import os
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-class Agent(BaseModel):
+
+class Assistant(BaseModel):
     # -*- Agent settings
-    name: Optional[str] = Field(None, description="Name of the agent.")
-    description: Optional[str] = Field(None, description="Description of the agent's role.")
-    instructions: Optional[List[str]] = Field(None, description="List of instructions for the agent.")
+    name: Optional[str] = Field(None, description="Name of the assistant.")
+    description: Optional[str] = Field(None, description="Description of the assistant's role.")
+    instructions: Optional[List[str]] = Field(None, description="List of instructions for the assistant.")
     model: Optional[str] = Field(None, description="This one is not in the use.")
     show_tool_calls: bool = Field(False, description="Whether to show tool calls in the response.")
     markdown: bool = Field(False, description="Whether to format the response in markdown.")
-    tools: Optional[List[BaseTool]] = Field(None, description="List of tools available to the agent.")
-    user_name: Optional[str] = Field("User", description="Name of the user interacting with the agent.")
-    emoji: Optional[str] = Field(":robot:", description="Emoji to represent the agent in the CLI.")
+    tools: Optional[List[BaseTool]] = Field(None, description="List of tools available to the assistant.")
+    user_name: Optional[str] = Field("User", description="Name of the user interacting with the assistant.")
+    emoji: Optional[str] = Field(":robot:", description="Emoji to represent the assistant in the CLI.")
     rag: Optional[RAG] = Field(None, description="RAG instance for context retrieval.")
     knowledge_base: Optional[Any] = Field(None, description="Knowledge base for domain-specific information.")
     llm: Optional[str] = Field(None, description="The LLM provider to use (e.g., 'groq', 'openai', 'anthropic').")
     llm_model: Optional[str] = Field(None, description="The specific model to use for the LLM provider.")
     llm_instance: Optional[BaseLLM] = Field(None, description="The LLM instance to use.")
     json_output: bool = Field(False, description="Whether to format the response as JSON.")
-    api: bool = Field(False, description="Whether to generate an API for the agent.")
+    api: bool = Field(False, description="Whether to generate an API for the assistant.")
     api_config: Optional[Dict] = Field(
         None,
         description="Configuration for the API (e.g., host, port, authentication).",
     )
     api_generator: Optional[Any] = Field(None, description="The API generator instance.")
     expected_output: Optional[Union[str, Dict]] = Field(None, description="The expected format or structure of the output.")
-    semantic_model: Optional[Any] = Field(None, description="SentenceTransformer model for semantic matching.")    
+    semantic_model: Optional[Any] = Field(None, description="SentenceTransformer model for semantic matching.")
+    team: Optional[List['Assistant']] = Field(None, description="List of assistants in the team.")
+    auto_tool: bool = Field(False, description="Whether to automatically detect and call tools.")
+    
     # Allow arbitrary types
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -52,8 +56,9 @@ class Agent(BaseModel):
         super().__init__(**kwargs)
         # Initialize the model and tools here if needed
         self._initialize_model()
-        # Automatically discover and register tools
-        self.tools = self._discover_tools()
+        # Automatically discover and register tools if not provided
+        if self.tools is None:
+            self.tools = self._discover_tools()
         # Pass the LLM instance to each tool
         for tool in self.tools:
             tool.llm = self.llm_instance
@@ -66,6 +71,41 @@ class Agent(BaseModel):
         if self.api:
             self._generate_api()
 
+
+    def _generate_response_from_image(self,message: str, image: Union[str, Image], markdown: bool = False, **kwargs) -> str:
+        """
+        Send the image to the LLM for analysis if the LLM supports vision.
+        Supports both local images (PIL.Image) and image URLs.
+        """
+        try:
+            # Check if the LLM supports vision
+            if not self.llm_instance or not self.llm_instance.supports_vision:
+                raise ValueError("Vision is not supported for the current model.")
+            prompt = self._build_prompt(message, context=None)
+            # Handle image URL
+            if isinstance(image, str) and image.startswith("http"):
+                # Directly pass the URL to the LLM
+                return self.llm_instance.generate_from_image_url(prompt,image, **kwargs)
+
+            # Handle local image (PIL.Image)
+            elif isinstance(image, Image):
+                # Convert the image to bytes
+                if image.mode == "RGBA":
+                    image = image.convert("RGB")  # Convert RGBA to RGB
+                image_bytes = io.BytesIO()
+                image.save(image_bytes, format="JPEG")  # Save as PNG (or any supported format)
+                image_bytes = image_bytes.getvalue()
+
+                # Generate response using base64-encoded image bytes
+                return self.llm_instance.generate_from_image(prompt,image_bytes, **kwargs)
+
+            else:
+                raise ValueError("Unsupported image type. Provide either a URL or a PIL.Image.")
+
+        except Exception as e:
+            logger.error(f"Failed to generate response from image: {e}")
+            return f"An error occurred while processing the image: {e}"
+        
     def _discover_tools(self) -> List[BaseTool]:
         """
         Automatically discover and register tools from the 'tools' directory.
@@ -122,12 +162,24 @@ class Agent(BaseModel):
             },
             "openai": {
                 "class": "OpenAILlm",
-                "default_model": "gpt-4",
+                "default_model": "gpt-4o",
             },
             "anthropic": {
                 "class": "AnthropicLlm",
                 "default_model": "claude-2.1",
             },
+            "deepseek": {
+                "class": "DeepSeekLLM",
+                "default_model": "deepseek-chat",
+            },
+            "gemini": {
+                "class": "GeminiLLM",
+                "default_model": "gemini-1.5-flash",
+            },
+            "mistral": {
+                "class": "MistralLLM",
+                "default_model": "mistral-large-latest",
+            },
         }
 
         # Normalize the LLM provider name (case-insensitive)
@@ -156,23 +208,16 @@ class Agent(BaseModel):
         retriever = Retriever(vector_store)
         return RAG(retriever)
 
-    def load_image_from_url(self, image_url: str) -> Image:
-        """Load an image from a URL and return it as a PIL Image."""
-        response = requests.get(image_url)
-        image_bytes = response.content
-        return Image.open(io.BytesIO(image_bytes))
-
     def print_response(
         self,
         message: Optional[Union[str, Image, List, Dict]] = None,
         stream: bool = False,
         markdown: bool = False,
+        tools: Optional[List[BaseTool]] = None,
+        team: Optional[List['Assistant']] = None,
         **kwargs,
     ) -> Union[str, Dict]:  # Add return type hint
-        """Print the agent's response to the console and return it."""
-        if isinstance(message, Image):
-            # Handle image input
-            message = self._process_image(message)
+        """Print the assistant's response to the console and return it."""
 
         if stream:
             # Handle streaming response
@@ -182,26 +227,21 @@ class Agent(BaseModel):
                 response += chunk
             return response
         else:
-             # Generate and return the response
-            response = self._generate_response(message, markdown=markdown, **kwargs)
+            # Generate and return the response
+            response = self._generate_response(message, markdown=markdown, tools=tools, team=team, **kwargs)
             print(response)  # Print the response to the console
             return response
 
-    def _process_image(self, image: Image) -> str:
-        """Process the image and return a string representation."""
-        # Convert the image to text or extract relevant information
-        # For now, we'll just return a placeholder string
-        return "Image processed. Extracted text: [Placeholder]"
 
     def _stream_response(self, message: str, markdown: bool = False, **kwargs) -> Iterator[str]:
-        """Stream the agent's response."""
+        """Stream the assistant's response."""
         # Simulate streaming by yielding chunks of the response
         response = self._generate_response(message, markdown=markdown, **kwargs)
         for chunk in response.split():
             yield chunk + " "
 
     def register_tool(self, tool: BaseTool):
-        """Register a tool for the agent."""
+        """Register a tool for the assistant."""
         if self.tools is None:
             self.tools = []
         self.tools.append(tool)
@@ -216,7 +256,7 @@ class Agent(BaseModel):
 
         # Create a prompt for the LLM
         prompt = f"""
-        You are an AI agent that helps users by selecting the most appropriate tool to answer their query. Below is a list of available tools and their functionalities:
+        You are an AI assistant that helps users by selecting the most appropriate tool to answer their query. Below is a list of available tools and their functionalities:
 
         {self._get_tool_descriptions()}
 
@@ -250,7 +290,7 @@ class Agent(BaseModel):
         """
         # Create a prompt for the LLM to analyze the query and select tools
         prompt = f"""
-        You are an AI agent that helps analyze user queries and select the most appropriate tools.
+        You are an AI assistant that helps analyze user queries and select the most appropriate tools.
         Below is a list of available tools and their functionalities:
 
         {self._get_tool_descriptions()}
@@ -284,20 +324,43 @@ class Agent(BaseModel):
             return []
     
 
-    def _generate_response(self, message: str, markdown: bool = False, **kwargs) -> str:
-        """Generate the agent's response, including tool execution and context retrieval."""
-        # Use the LLM to analyze the query and dynamically select tools
-        tool_calls = self._analyze_query_and_select_tools(message)
-    
+    def _generate_response(self, message: str, markdown: bool = False, tools: Optional[List[BaseTool]] = None, team: Optional[List['Assistant']] = None, **kwargs) -> str:
+        """Generate the assistant's response, including tool execution and context retrieval."""
+        # Use the specified tools or team if provided
+        if tools is not None:
+            self.tools = tools
+        if team is not None:
+            return self._generate_team_response(message, team, markdown=markdown, **kwargs)
+
+        # Initialize tool_outputs as an empty dictionary
+        tool_outputs = {}
         responses = []
-        tool_outputs = {}  # Store outputs of all tools for collaboration
 
-        # Execute tools if any are detected
+        # Use the LLM to analyze the query and dynamically select tools when auto_tool is enabled
+        if self.auto_tool:
+            tool_calls = self._analyze_query_and_select_tools(message)
+        else:
+            # Check if tools are provided
+            if self.tools:
+                tool_calls = [
+                    {
+                        "tool": tool.__class__.__name__,
+                        "input": {
+                            "query": message,  # Use the message as the query
+                            "context": None,  # No context provided by default
+                        }
+                    }
+                    for tool in self.tools
+                ]
+            else:
+                tool_calls = kwargs.get("tool_calls", [])
+
+            # Execute tools if any are detected
         if tool_calls:
             for tool_call in tool_calls:
                 tool_name = tool_call["tool"]
                 tool_input = tool_call["input"]
-            
+
                 # Find the tool
                 tool = next((t for t in self.tools if t.name.lower() == tool_name.lower()), None)
                 if tool:
@@ -333,9 +396,8 @@ class Agent(BaseModel):
             except Exception as e:
                 logger.error(f"Failed to generate LLM response: {e}")
                 responses.append(f"An error occurred while generating the analysis: {e}")
-
-        # If no tools were executed, proceed with the original logic
         if not tool_calls:
+            # If no tools were executed, proceed with the original logic
             # Retrieve relevant context using RAG
             rag_context = self.rag.retrieve(message) if self.rag else None
             # Retrieve relevant context from the knowledge base (API result)
@@ -370,8 +432,15 @@ class Agent(BaseModel):
             if markdown:
                 return f"**Response:**\n\n{response}"
             return response
-
-        # Combine all responses into a single output
+        # Combine all responses into a single string
+        return "\n\n".join(responses)
+    
+    def _generate_team_response(self, message: str, team: List['Assistant'], markdown: bool = False, **kwargs) -> str:
+        """Generate a response using a team of assistants."""
+        responses = []
+        for assistant in team:
+            response = assistant.print_response(message, markdown=markdown, **kwargs)
+            responses.append(f"**{assistant.name}:**\n\n{response}")
         return "\n\n".join(responses)
 
     def _build_prompt(self, message: str, context: Optional[List[Dict]]) -> str:
@@ -509,7 +578,7 @@ class Agent(BaseModel):
         exit_on: Optional[List[str]] = None,
         **kwargs,
     ):
-        """Run the agent in a CLI app."""
+        """Run the assistant in a CLI app."""
         from rich.prompt import Prompt
 
         if message:
@@ -524,15 +593,15 @@ class Agent(BaseModel):
             self.print_response(message=message, **kwargs)
 
     def _generate_api(self):
-        """Generate an API for the agent if api=True."""
+        """Generate an API for the assistant if api=True."""
         from .api.api_generator import APIGenerator
         self.api_generator = APIGenerator(self)
-        print(f"API generated for agent '{self.name}'. Use `.run_api()` to start the API server.")
+        print(f"API generated for assistant '{self.name}'. Use `.run_api()` to start the API server.")
 
     def run_api(self):
-        """Run the API server for the agent."""
+        """Run the API server for the assistant."""
         if not hasattr(self, 'api_generator'):
-            raise ValueError("API is not enabled for this agent. Set `api=True` when initializing the agent.")
+            raise ValueError("API is not enabled for this assistant. Set `api=True` when initializing the assistant.")
     
         # Get API configuration
         host = self.api_config.get("host", "0.0.0.0") if self.api_config else "0.0.0.0"

semantio/llm/__init__.py

@@ -1,17 +1,24 @@
 from .openai import OpenAILlm
-from .anthropic import AnthropicLlm
-# from .llama import LlamaLlm
+from .anthropic import AnthropicLLM
 from .groq import GroqLlm
+from .mistral import MistralLLM
+from .deepseek import DeepSeekLLM
+from .gemini import GeminiLLM
 
 def get_llm(provider: str, **kwargs):
     provider = provider.lower()  # Convert provider name to lowercase
     if provider == "openai":
         return OpenAILlm(**kwargs)
     elif provider == "anthropic":
-        return AnthropicLlm(**kwargs)
-    # elif provider == "llama":
-    #     return LlamaLlm(**kwargs)
+        return AnthropicLLM(**kwargs)
     elif provider == "groq":
         return GroqLlm(**kwargs)
+    elif provider == "mistral":
+        return MistralLLM(**kwargs)
+    elif provider == "deepseek":
+        return DeepSeekLLM(**kwargs)
+    elif provider == "gemini":
+        return GeminiLLM(**kwargs)
+    
     else:
         raise ValueError(f"Unsupported LLM provider: {provider}")

semantio/llm/anthropic.py

@@ -1,39 +1,52 @@
+import os
 from typing import List, Dict, Optional
 from .base_llm import BaseLLM
 import anthropic
-import os
 
-class AnthropicLlm(BaseLLM):
-    def __init__(
-        self,
-        model: str = "claude-2.1",  # Default Anthropic model
-        api_key: Optional[str] = None,
-    ):
+class AnthropicLLM(BaseLLM):
+    def __init__(self, model: str = "claude-3-5-sonnet-20241022", api_key: Optional[str] = None):
+        """
+        Initialize the Anthropic LLM class.
+
+        Args:
+            model (str): The name of the model (e.g., claude-3-5-sonnet-20241022).
+            api_key (Optional[str]): The Anthropic API key. If not provided, it fetches from the environment.
+        """
         self.model = model
         self.api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
         if not self.api_key:
             raise ValueError("Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or pass it explicitly.")
-        self.client = anthropic.Client(api_key=self.api_key)
+        self.client = anthropic.Anthropic(api_key=self.api_key)
+
+    def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
+        """
+        Generate text using Anthropic's Claude model.
+
+        Args:
+            prompt (str): The user prompt.
+            context (Optional[List[Dict]]): Context to include in the conversation.
+            memory (Optional[List[Dict]]): Memory from previous interactions.
 
-    def generate(
-        self,
-        prompt: str,
-        context: Optional[List[Dict]] = None,
-        memory: Optional[List[Dict]] = None,
-    ) -> str:
-        # Prepare messages for the Anthropic API
-        messages = []
-        if memory:
-            messages.extend(memory)
-        if context:
-            messages.append({"role": "system", "content": "Context: " + str(context)})
-        messages.append({"role": "user", "content": prompt})
+        Returns:
+            str: The generated response from the model.
+        """
+        try:
+            # Prepare messages for the Anthropic API
+            messages = []
+            if memory:
+                messages.extend(memory)
+            if context:
+                messages.append({"role": "system", "content": "Context: " + str(context)})
+            messages.append({"role": "user", "content": prompt})
 
-        # Call Anthropic API
-        response = self.client.completion(
-            model=self.model,
-            messages=messages,
-        )
+            # Call the Anthropic API
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=1024,
+                messages=messages,
+            )
 
-        # Extract and return the response
-        return response.choices[0].message.content
+            # Extract and return the response
+            return response.content
+        except Exception as e:
+            raise ValueError(f"Error while generating response with Anthropic Claude: {e}")

semantio/llm/base_llm.py

@@ -9,4 +9,13 @@ class BaseLLM(ABC):
         context: Optional[List[Dict]] = None,
         memory: Optional[List[Dict]] = None,
     ) -> str:
-        pass
+        pass
+
+    @property
+    def supports_vision(self) -> bool:
+        """Return True if the LLM supports vision tasks."""
+        return False
+
+    def generate_from_image(self, image_bytes: bytes, **kwargs) -> str:
+        """Process an image if vision is supported. Default implementation raises an error."""
+        raise NotImplementedError("This LLM does not support vision tasks.")

semantio/llm/deepseek.py

@@ -0,0 +1,27 @@
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+from openai import OpenAI
+import os
+
+class DeepSeekLLM(BaseLLM):
+    def __init__(self, model: str = "deepseek-chat", api_key: Optional[str] = None):
+        self.model = model
+        self.api_key = api_key or os.getenv("DEEPSEEK_API_KEY")
+        if not self.api_key:
+            raise ValueError("DeepSeek API key is required. Set DEEPSEEK_API_KEY environment variable or pass it explicitly.")
+        self.client = OpenAI(api_key=self.api_key, base_url="https://api.deepseek.com")
+
+    def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
+        messages = []
+        if memory:
+            messages.extend(memory)
+        if context:
+            messages.append({"role": "system", "content": "Context: " + str(context)})
+        messages.append({"role": "user", "content": prompt})
+
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+        )
+
+        return response.choices[0].message.content

semantio/llm/gemini.py

@@ -0,0 +1,50 @@
+import os
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+from google import genai
+
+class GeminiLLM(BaseLLM):
+    def __init__(self, model: str = "gemini-1.5-flash", api_key: Optional[str] = None):
+        """
+        Initialize the Gemini LLM class.
+
+        Args:
+            model (str): The name of the Gemini model (e.g., 'gemini-1.5-flash').
+            api_key (Optional[str]): The Gemini API key. If not provided, it fetches from the environment.
+        """
+        self.model = model
+        self.api_key = api_key or os.getenv("GEMINI_API_KEY")
+        if not self.api_key:
+            raise ValueError("Gemini API key is required. Set GEMINI_API_KEY environment variable or pass it explicitly.")
+        
+        # Initialize the client using the API key
+        self.client = genai.Client(api_key=self.api_key)
+
+    def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
+        """
+        Generate text using Google's Gemini model.
+
+        Args:
+            prompt (str): The user prompt.
+            context (Optional[List[Dict]]): Context to include in the conversation.
+            memory (Optional[List[Dict]]): Memory from previous interactions.
+
+        Returns:
+            str: The generated response from the model.
+        """
+        try:
+            # Prepare the chat history (optional context and memory)
+            history = memory if memory else []
+            if context:
+                history.append({"role": "system", "content": str(context)})
+
+            # Generate the content using the specified Gemini model
+            response = self.client.models.generate_content(
+                model=self.model,
+                contents=prompt
+            )
+
+            # Return the response text
+            return response.text
+        except Exception as e:
+            raise ValueError(f"Error while generating response with Gemini: {e}")

semantio/llm/groq.py

@@ -1,4 +1,5 @@
-from typing import List, Dict, Optional
+import base64
+from typing import Optional, List, Dict
 from .base_llm import BaseLLM
 import groq
 import os
@@ -15,12 +16,22 @@ class GroqLlm(BaseLLM):
             raise ValueError("Groq API key is required. Set GROQ_API_KEY environment variable or pass it explicitly.")
         self.client = groq.Client(api_key=self.api_key)
 
-    def generate(
-        self,
-        prompt: str,
-        context: Optional[List[Dict]] = None,
-        memory: Optional[List[Dict]] = None,
-    ) -> str:
+    @property
+    def supports_vision(self) -> bool:
+        """
+        Check if the model supports vision tasks.
+        """
+        # List of Groq models that support vision
+        vision_models = [
+            "llama-3.2-11b-vision-preview",
+            "llama-3.2-90b-vision-preview"
+        ]
+        return self.model in vision_models
+
+    def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
+        """
+        Generate a response to a text-based prompt.
+        """
         # Prepare messages for the Groq API
         messages = []
         if memory:
@@ -36,4 +47,75 @@ class GroqLlm(BaseLLM):
         )
 
         # Extract and return the response
-        return response.choices[0].message.content
+        return response.choices[0].message.content
+
+    def generate_from_image(self, prompt: str, image_bytes: bytes, **kwargs) -> str:
+        """
+        Process an image and generate a response if the model supports vision.
+        """
+        if not self.supports_vision:
+            raise ValueError(f"Model '{self.model}' does not support vision tasks.")
+
+        try:
+            # Convert the image bytes to base64
+            image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+            
+            # Construct the message payload
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{image_base64}",
+                            },
+                        },
+                    ],
+                }
+            ]
+
+            # Call the Groq API with the base64-encoded image
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                **kwargs,
+            )
+
+            # Extract and return the response text
+            return response.choices[0].message.content
+        except Exception as e:
+            raise ValueError(f"Error while processing image with Groq vision model: {e}")
+
+
+    def generate_from_image_url(self, prompt: str, image_url: str, **kwargs) -> str:
+        """
+        Process an image URL and generate a response if the model supports vision.
+        """
+        if not self.supports_vision:
+            raise ValueError(f"Model '{self.model}' does not support vision tasks.")
+
+        try:
+            # Call the Groq API with the image URL
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": image_url,
+                                },
+                            },
+                        ],
+                    }
+                ],
+                **kwargs,
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            raise ValueError(f"Error while processing image URL with Groq vision model: {e}")

semantio/llm/mistral.py

@@ -0,0 +1,27 @@
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+from mistralai import Mistral
+import os
+
+class MistralLLM(BaseLLM):
+    def __init__(self, model: str = "mistral-large-latest", api_key: Optional[str] = None):
+        self.model = model
+        self.api_key = api_key or os.getenv("MISTRAL_API_KEY")
+        if not self.api_key:
+            raise ValueError("Mistral API key is required. Set MISTRAL_API_KEY environment variable or pass it explicitly.")
+        self.client = Mistral(api_key=self.api_key)
+
+    def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
+        messages = []
+        if memory:
+            messages.extend(memory)
+        if context:
+            messages.append({"role": "system", "content": "Context: " + str(context)})
+        messages.append({"role": "user", "content": prompt})
+
+        response = self.client.chat.complete(
+            model=self.model,
+            messages=messages,
+        )
+
+        return response.choices[0].message.content

semantio/llm/openai.py

@@ -1,26 +1,136 @@
 from typing import List, Dict, Optional
 from .base_llm import BaseLLM
-import openai
+from openai import OpenAI
 import os
+import base64
 
 class OpenAILlm(BaseLLM):
-    def __init__(self, model: str = "gpt-4", api_key: Optional[str] = None):
+    def __init__(self, model: str = "gpt-4o", api_key: Optional[str] = None):
+        """
+        Initialize the OpenAI LLM class.
+
+        Args:
+            model (str): The name of the model (e.g., gpt-4o, gpt-4-vision).
+            api_key (Optional[str]): The OpenAI API key. If not provided, it fetches from the environment.
+        """
         self.model = model
         self.api_key = api_key or os.getenv("OPENAI_API_KEY")
         if not self.api_key:
             raise ValueError("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it explicitly.")
-        openai.api_key = self.api_key
+        self.client = OpenAI(api_key=self.api_key)
 
     def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
-        messages = []
-        if memory:
-            messages.extend(memory)
-        if context:
-            messages.append({"role": "system", "content": "Context: " + str(context)})
-        messages.append({"role": "user", "content": prompt})
-
-        response = openai.ChatCompletion.create(
-            model=self.model,
-            messages=messages,
-        )
-        return response.choices[0].message["content"]
+        """
+        Generate text using OpenAI's ChatCompletion API.
+
+        Args:
+            prompt (str): The user prompt.
+            context (Optional[List[Dict]]): Context to include in the conversation.
+            memory (Optional[List[Dict]]): Memory from previous interactions.
+
+        Returns:
+            str: The generated response from the model.
+        """
+        try:
+            # Prepare messages for the OpenAI API
+            messages = []
+            if memory:
+                messages.extend(memory)
+            if context:
+                messages.append({"role": "system", "content": "Context: " + str(context)})
+            messages.append({"role": "user", "content": prompt})
+
+            # Call the ChatCompletion endpoint
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+            )
+
+            # Extract and return the response:
+            return response.choices[0].message.content
+        except Exception as e:
+            raise ValueError(f"Error while generating response with OpenAI: {e}")
+
+    @property
+    def supports_vision(self) -> bool:
+        """
+        Check if the model supports vision tasks.
+        """
+        # List of GPT models that support vision
+        vision_models =[
+            "gpt-4o", "gpt-4o mini", "o1", "o1 mini"
+        ]
+        return self.model in vision_models
+
+    def generate_from_image_url(self, prompt: str, image_url: str, **kwargs) -> str:
+        """
+        Process an image URL with OpenAI's vision-capable models, using instructions as the prompt.
+
+        Args:
+            image_url (str): The URL of the image.
+            instructions (str): Instructions provided as the prompt for image analysis.
+            kwargs: Additional parameters for the OpenAI API.
+
+        Returns:
+            str: The response generated by the vision-capable model.
+        """
+        if not self.supports_vision:
+            raise ValueError(f"Model '{self.model}' does not support vision tasks.")
+
+        try:
+            # Use instructions as the prompt in the API call
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},  # Using instructions as the prompt
+                            {"type": "image_url", "image_url": {"url": image_url,},},
+                        ],
+                    }
+                ],
+                **kwargs,
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            raise ValueError(f"Error while processing image URL with OpenAI Vision model: {e}")
+
+    def generate_from_image(self, prompt: str, image_bytes: bytes, **kwargs) -> str:
+        """
+        Process an image and generate a response if the model supports vision.
+        """
+        if not self.supports_vision:
+            raise ValueError(f"Model '{self.model}' does not support vision tasks.")
+
+        try:
+            # Convert the image bytes to base64
+            image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+            
+            # Construct the message payload
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{image_base64}",
+                            },
+                        },
+                    ],
+                }
+            ]
+
+            # Call the Groq API with the base64-encoded image
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                **kwargs,
+            )
+
+            # Extract and return the response text
+            return response.choices[0].message.content
+        except Exception as e:
+            raise ValueError(f"Error while processing image with OpenAI vision model: {e}")

{semantio-0.0.1.dist-info → semantio-0.0.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: semantio
-Version: 0.0.1
-Summary: A powerful SDK for building AI agents with RAG capabilities.
+Version: 0.0.2
+Summary: A powerful SDK for building AI agents
 Home-page: https://github.com/Syenah/semantio
 Author: Rakesh
 Author-email: rakeshsahoo689@gmail.com
@@ -19,7 +19,8 @@ License-File: LICENSE
 Requires-Dist: openai
 Requires-Dist: anthropic
 Requires-Dist: groq
-Requires-Dist: langchain
+Requires-Dist: google-genai
+Requires-Dist: mistralai
 Requires-Dist: faiss-cpu
 Requires-Dist: pydantic
 Requires-Dist: requests
@@ -32,8 +33,6 @@ Requires-Dist: sentence-transformers
 Requires-Dist: fuzzywuzzy
 Requires-Dist: duckduckgo-search
 Requires-Dist: yfinance
-Requires-Dist: forex-python
-Requires-Dist: qrcode
 
 # Semantio: The Mother of Your AI Agents
 
@@ -112,7 +111,9 @@ Semantio/
 │   │   ├── __init__.py
 │   │   ├── openai.py            # OpenAI integration
 │   │   ├── anthropic.py         # Anthropic (Claude) integration
-│   │   ├── llama.py             # Llama 2 integration
+│   │   ├── deepseek.py          # Deepseek integration
+│   │   ├── gemini.py            # Gemini integration
+│   │   ├── mistral.py           # Mistral integration
 │   │   └── base_llm.py          # Base class for LLMs
 │   ├── knowledge_base/          # Knowledge base integration
 │   │   ├── __init__.py

{semantio-0.0.1.dist-info → semantio-0.0.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 semantio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/agent.py,sha256=iS9Yf18iG43SYTxSjmYCZl69OinRKqiVvnBtvLnEF8o,27001
+semantio/agent.py,sha256=mwcKaHy-HY26hxgCRZS5LZw1semlj59qF4uYcLpyqBc,30247
 semantio/memory.py,sha256=eNAwyAokppHzMcIyFgOw2hT2wnLQBd9GL4T5eallNV4,281
 semantio/rag.py,sha256=ROy3Pa1NURcDs6qQZ8IMoa5Xlzt6I-msEq0C1p8UgB0,472
 semantio/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -11,12 +11,15 @@ semantio/knowledge_base/__init__.py,sha256=mvp0GFiGSjcxlkaDulAwKOCL9s6gsKTqhPKXF
 semantio/knowledge_base/document_loader.py,sha256=nix0yZJ-JJoDbhLkpg5bKDMvNrwykmknI7MRIn0N81k,1910
 semantio/knowledge_base/retriever.py,sha256=XpdzKS1UCncJImVMtG67VXMC7lp2eRzKnShjvktsFMM,1271
 semantio/knowledge_base/vector_store.py,sha256=4Zv9kfqDD3cfn_4R8ZoLKdAQCZRYo_IENP_KkLB_RPc,987
-semantio/llm/__init__.py,sha256=aZ1vA6qdnz0481Xhi-5GpnxmqyO-5pLYQgww6xYaT-4,572
-semantio/llm/anthropic.py,sha256=nGq52klAz_N3foJJRNgUwW9LNpBHmZx-y-EEwR4yh78,1268
-semantio/llm/base_llm.py,sha256=YezjFrgAz-2jT7t70EnE3x-OHoWFxauBlhrQxP4RJk0,287
-semantio/llm/groq.py,sha256=ZfYoZ5c7oW9GoryJBeKhthqB91zC-LilOVnMoiu9Opg,1244
+semantio/llm/__init__.py,sha256=-4uKcqo9fBrEbvfxGE01XVHL9qEG2vKXfy5hlnUsRbw,779
+semantio/llm/anthropic.py,sha256=-JTso9vr88T3JSipxE60uZjqDgfla1QFoSEBpXW2pXw,2054
+semantio/llm/base_llm.py,sha256=VFl_2S4kqYDuCTWIfWMbKU5aNbVqOCG33E4APOSHF90,668
+semantio/llm/deepseek.py,sha256=oxX-Uw0_lY2sstYs5KGBGFB_hAZUbZomPADdib1mY2M,1100
+semantio/llm/gemini.py,sha256=er3zv1jOvWQBGbPuv4fS4pR_c_abHyhroe-rkXupOO4,1959
+semantio/llm/groq.py,sha256=1AH30paKzDIQjBjWPQPN44QwFHsIOVwI-a587-cDIVc,4285
 semantio/llm/llama.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/llm/openai.py,sha256=F0sFYsJv6XdDQFNoG2dkGH8QuD5iE5hQ3-ulGYnLnJc,1016
+semantio/llm/mistral.py,sha256=NpvaB1cE6-jMEBdT0mTf6Ca4Qq2LS8QivDKI6AgdRjE,1061
+semantio/llm/openai.py,sha256=I3ab-d_zFxm-TDhYk6t1PzDtElPJEEQ2eSiARBNIGi4,5174
 semantio/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantio/storage/cloud_storage.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantio/storage/local_storage.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,9 +35,9 @@ semantio/utils/date_utils.py,sha256=x3oqRGv6ee_KCJ0LvCqqZh_FSgS6YGOHBwZQS4TJetY,
 semantio/utils/file_utils.py,sha256=b_cMuJINEGk9ikNuNHSn9lsmICWwvtnCDZ03ndH_S2I,1779
 semantio/utils/logger.py,sha256=TmGbP8BRjLMWjXi2GWzZ0RIXt70x9qX3FuIqghCNlwM,510
 semantio/utils/validation_utils.py,sha256=iwoxEb4Q5ILqV6tbesMjPWPCCoL3AmPLejGUy6q8YvQ,1284
-semantio-0.0.1.dist-info/LICENSE,sha256=teQbWD2Zlcl1_Fo29o2tNbs6G26hbCQiUzds5fQGYlY,1063
-semantio-0.0.1.dist-info/METADATA,sha256=XvS9jISWNZ6PeqdbuTRH9heUdfopa2ILmlrnQOSnBZk,6715
-semantio-0.0.1.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-semantio-0.0.1.dist-info/entry_points.txt,sha256=zbPgevSLwcLpdRHqI_atE8EOt8lK2vRF1AoDflDTo18,53
-semantio-0.0.1.dist-info/top_level.txt,sha256=Yte_6mb-bh-I_lQwMjk1GijZkxPoX4Zmp3kBftC1ZlA,9
-semantio-0.0.1.dist-info/RECORD,,
+semantio-0.0.2.dist-info/LICENSE,sha256=teQbWD2Zlcl1_Fo29o2tNbs6G26hbCQiUzds5fQGYlY,1063
+semantio-0.0.2.dist-info/METADATA,sha256=LsBDOM1gPw6rbzZ_-TIf4XJxf3DEWZ7s8KDd8_cDMw0,6800
+semantio-0.0.2.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+semantio-0.0.2.dist-info/entry_points.txt,sha256=zbPgevSLwcLpdRHqI_atE8EOt8lK2vRF1AoDflDTo18,53
+semantio-0.0.2.dist-info/top_level.txt,sha256=Yte_6mb-bh-I_lQwMjk1GijZkxPoX4Zmp3kBftC1ZlA,9
+semantio-0.0.2.dist-info/RECORD,,