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

semantio/agent.py

@@ -20,6 +20,7 @@ import os
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
+
 class Agent(BaseModel):
     # -*- Agent settings
     name: Optional[str] = Field(None, description="Name of the agent.")
@@ -44,7 +45,10 @@ class Agent(BaseModel):
     )
     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['Agent']] = 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.
@@ -85,7 +125,7 @@ class Agent(BaseModel):
             try:
                 # Import the module
                 module_name = file.stem
-                module = importlib.import_module(f"hashai.tools.{module_name}")
+                module = importlib.import_module(f"semantio.tools.{module_name}")
 
                 # Find all classes that inherit from BaseTool
                 for name, obj in module.__dict__.items():
@@ -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)
@@ -145,7 +197,7 @@ class Agent(BaseModel):
         model_to_use = self.llm_model or default_model
 
         # Dynamically import and initialize the LLM class
-        module_name = f"hashai.llm.{llm_provider}"
+        module_name = f"semantio.llm.{llm_provider}"
         llm_module = importlib.import_module(module_name)
         llm_class = getattr(llm_module, llm_class_name)
         self.llm_instance = llm_class(model=model_to_use, api_key=api_key)
@@ -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['Agent']] = 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)
 
         if stream:
             # Handle streaming response
@@ -182,16 +227,11 @@ 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."""
@@ -284,20 +324,43 @@ class Agent(BaseModel):
             return []
     
 
-    def _generate_response(self, message: str, markdown: bool = False, **kwargs) -> str:
+    def _generate_response(self, message: str, markdown: bool = False, tools: Optional[List[BaseTool]] = None, team: Optional[List['Agent']] = None, **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)
-    
+        # 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['Agent'], markdown: bool = False, **kwargs) -> str:
+        """Generate a response using a team of assistants."""
+        responses = []
+        for agent in team:
+            response = agent.print_response(message, markdown=markdown, **kwargs)
+            responses.append(f"**{agent.name}:**\n\n{response}")
         return "\n\n".join(responses)
 
     def _build_prompt(self, message: str, context: Optional[List[Dict]]) -> str:

semantio/cli/main.py

@@ -1,7 +1,7 @@
 import argparse
 import warnings
-from hashai.assistant import Assistant
-from hashai.llm import get_llm
+from semantio.agent import Agent
+from semantio.llm import get_llm
 from urllib3.exceptions import NotOpenSSLWarning
 
 # Suppress the NotOpenSSLWarning
@@ -9,7 +9,7 @@ warnings.filterwarnings("ignore", category=NotOpenSSLWarning)
 
 def main():
     parser = argparse.ArgumentParser(description="opAi CLI")
-    parser.add_argument("--message", type=str, required=True, help="Message to send to the assistant")
+    parser.add_argument("--message", type=str, required=True, help="Message to send to the agent")
     parser.add_argument("--provider", type=str, required=True, help="LLM provider (e.g., groq, openai)")
     parser.add_argument("--api-key", type=str, required=True, help="API key for the LLM provider")
     parser.add_argument("--model", type=str, default=None, help="Model name (e.g., mixtral-8x7b-32768)")
@@ -22,9 +22,9 @@ def main():
 
     llm = get_llm(provider=args.provider, **llm_config)
 
-    # Create an assistant
-    assistant = Assistant(model=args.provider, llm=llm)
-    assistant.print_response(args.message)
+    # Create an agent
+    agent = Agent(model=args.provider, llm=llm)
+    agent.print_response(args.message)
     
 
 if __name__ == "__main__":

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.3.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.3
+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.3.dist-info}/RECORD

@@ -1,22 +1,24 @@
 semantio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/agent.py,sha256=iS9Yf18iG43SYTxSjmYCZl69OinRKqiVvnBtvLnEF8o,27001
+semantio/agent.py,sha256=plQ4D76cnJ1FaGlEuKDeA53aW_hMDvt5sbmUuTHqvFQ,30143
 semantio/memory.py,sha256=eNAwyAokppHzMcIyFgOw2hT2wnLQBd9GL4T5eallNV4,281
 semantio/rag.py,sha256=ROy3Pa1NURcDs6qQZ8IMoa5Xlzt6I-msEq0C1p8UgB0,472
 semantio/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantio/api/api_generator.py,sha256=Q-USITEpluRESEaQuOmF7m1vhLKYU9P8eGlQppKT9J4,829
 semantio/api/fastapi_app.py,sha256=DyTgKJKikMe2G6wWmyzo1rBLXQFi8UWWUMY3UGH4f24,2128
 semantio/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/cli/main.py,sha256=BvY2B2xUSV1Q-4K6eH5P1tJB2Y0aL_rm-1ZW-D0F3eU,1115
+semantio/cli/main.py,sha256=jUvSfehbHWALwracEgBopMIVMraSV9QmDUFfgGcxnP0,1091
 semantio/knowledge_base/__init__.py,sha256=mvp0GFiGSjcxlkaDulAwKOCL9s6gsKTqhPKXF9N3n1g,172
 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/llama.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/llm/openai.py,sha256=F0sFYsJv6XdDQFNoG2dkGH8QuD5iE5hQ3-ulGYnLnJc,1016
+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/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
@@ -25,16 +27,15 @@ semantio/tools/base_tool.py,sha256=xBNSa_8a8WmA4BGRLG2dE7wj9GnBcZo7-P2SyD86GvY,5
 semantio/tools/crypto.py,sha256=mut1ztvpPcUUP3b563dh_FmKtP68KmNis3Qm8WENj8w,5559
 semantio/tools/duckduckgo.py,sha256=6mGn0js0cIsVxQlAgB8AYNLP05H8WmJKnSVosiO9iH0,5034
 semantio/tools/stocks.py,sha256=BVuK61O9OmWQjj0YdiCJY6TzpiFJ_An1UJB2RkDfX2k,5393
-semantio/tools/web_browser.py,sha256=LMwPFTHNTtqCp8MEHVlJJUSJa91vM7MZWIL5RDQKF4U,4980
 semantio/utils/__init__.py,sha256=Lx4X4iJpRhZzRmpQb80XXh5Ve8ZMOkadWAxXSmHpO_8,244
 semantio/utils/config.py,sha256=ZTwUTqxjW3-w94zoU7GzivWyJe0JJGvBfuB4RUOuEs8,1198
 semantio/utils/date_utils.py,sha256=x3oqRGv6ee_KCJ0LvCqqZh_FSgS6YGOHBwZQS4TJetY,1471
 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.3.dist-info/LICENSE,sha256=teQbWD2Zlcl1_Fo29o2tNbs6G26hbCQiUzds5fQGYlY,1063
+semantio-0.0.3.dist-info/METADATA,sha256=M5Q-waTknpyWrD_HV9G76jMKgPHPrBBwM5Hl8we4ulo,6800
+semantio-0.0.3.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+semantio-0.0.3.dist-info/entry_points.txt,sha256=zbPgevSLwcLpdRHqI_atE8EOt8lK2vRF1AoDflDTo18,53
+semantio-0.0.3.dist-info/top_level.txt,sha256=Yte_6mb-bh-I_lQwMjk1GijZkxPoX4Zmp3kBftC1ZlA,9
+semantio-0.0.3.dist-info/RECORD,,

semantio/tools/web_browser.py

@@ -1,153 +0,0 @@
-from typing import Dict, Any, Optional, List
-from playwright.async_api import async_playwright
-import asyncio
-import logging
-
-logger = logging.getLogger(__name__)
-
-class WebBrowserTool:
-    """
-    A tool for performing browser automation tasks using Playwright.
-    """
-
-    def __init__(self, headless: bool = True):
-        """
-        Initialize the WebBrowserTool.
-
-        Args:
-            headless (bool): Whether to run the browser in headless mode (default: True).
-        """
-        self.headless = headless
-        self.browser = None
-        self.context = None
-        self.page = None
-
-    async def start(self):
-        """
-        Start the browser and create a new context and page.
-        """
-        self.playwright = await async_playwright().start()
-        self.browser = await self.playwright.chromium.launch(headless=self.headless)
-        self.context = await self.browser.new_context()
-        self.page = await self.context.new_page()
-        logger.info("Browser started successfully.")
-
-    async def close(self):
-        """
-        Close the browser and cleanup resources.
-        """
-        if self.browser:
-            await self.browser.close()
-        await self.playwright.stop()
-        logger.info("Browser closed successfully.")
-
-    async def navigate(self, url: str) -> str:
-        """
-        Navigate to a specific URL.
-
-        Args:
-            url (str): The URL to navigate to.
-
-        Returns:
-            str: The page title after navigation.
-        """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
-
-        await self.page.goto(url)
-        title = await self.page.title()
-        logger.info(f"Navigated to {url}. Page title: {title}")
-        return title
-
-    async def fill_form(self, fields: Dict[str, str]) -> str:
-        """
-        Fill a form with the provided fields.
-
-        Args:
-            fields (Dict[str, str]): A dictionary of field names and values to fill.
-
-        Returns:
-            str: A success message.
-        """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
-
-        for field, value in fields.items():
-            await self.page.fill(f'input[name="{field}"]', value)
-            logger.info(f"Filled field '{field}' with value '{value}'.")
-
-        return "Form filled successfully."
-
-    async def click(self, selector: str) -> str:
-        """
-        Click an element on the page.
-
-        Args:
-            selector (str): The CSS selector of the element to click.
-
-        Returns:
-            str: A success message.
-        """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
-
-        await self.page.click(selector)
-        logger.info(f"Clicked element with selector '{selector}'.")
-        return f"Clicked element: {selector}"
-
-    async def scrape(self, selector: str) -> List[Dict[str, str]]:
-        """
-        Scrape data from the page.
-
-        Args:
-            selector (str): The CSS selector of the elements to scrape.
-
-        Returns:
-            List[Dict[str, str]]: A list of dictionaries containing the scraped data.
-        """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
-
-        elements = await self.page.query_selector_all(selector)
-        scraped_data = []
-        for element in elements:
-            text = await element.inner_text()
-            scraped_data.append({"text": text.strip()})
-            logger.info(f"Scraped text: {text.strip()}")
-
-        return scraped_data
-
-    async def execute_step(self, step: Dict[str, Any]) -> str:
-        """
-        Execute a browser automation step.
-
-        Args:
-            step (Dict[str, Any]): A dictionary containing the step details.
-                - "action": The action to perform (e.g., "navigate", "fill_form", "click", "scrape").
-                - "details": The details required for the action (e.g., URL, form fields, selector).
-                - "website": The website to perform the action on (optional).
-
-        Returns:
-            str: The result of the step execution.
-        """
-        action = step.get("action")
-        details = step.get("details")
-        website = step.get("website", "https://www.google.com")
-
-        if not self.page:
-            await self.start()
-
-        try:
-            if action == "navigate":
-                return await self.navigate(details)
-            elif action == "fill_form":
-                return await self.fill_form(details)
-            elif action == "click":
-                return await self.click(details)
-            elif action == "scrape":
-                return str(await self.scrape(details))
-            else:
-                return f"Unknown action: {action}"
-        except Exception as e:
-            logger.error(f"Error executing step: {e}")
-            return f"Error executing step: {e}"