semantio 0.0.1__tar.gz → 0.0.2__tar.gz

{semantio-0.0.1 → semantio-0.0.2}/PKG-INFO

@@ -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
@@ -94,7 +94,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 → semantio-0.0.2}/README.md

@@ -75,7 +75,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 → semantio-0.0.2}/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-0.0.1 → semantio-0.0.2}/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-0.0.2/semantio/llm/anthropic.py

@@ -0,0 +1,52 @@
+import os
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+import anthropic
+
+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.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.
+
+        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 the Anthropic API
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=1024,
+                messages=messages,
+            )
+
+            # Extract and return the response
+            return response.content
+        except Exception as e:
+            raise ValueError(f"Error while generating response with Anthropic Claude: {e}")

semantio-0.0.2/semantio/llm/base_llm.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional
+
+class BaseLLM(ABC):
+    @abstractmethod
+    def generate(
+        self,
+        prompt: str,
+        context: Optional[List[Dict]] = None,
+        memory: Optional[List[Dict]] = None,
+    ) -> str:
+        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-0.0.2/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-0.0.2/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-0.0.2/semantio/llm/groq.py

@@ -0,0 +1,121 @@
+import base64
+from typing import Optional, List, Dict
+from .base_llm import BaseLLM
+import groq
+import os
+
+class GroqLlm(BaseLLM):
+    def __init__(
+        self,
+        model: str = "mixtral-8x7b-32768",  # Default Groq model
+        api_key: Optional[str] = None,
+    ):
+        self.model = model
+        self.api_key = api_key or os.getenv("GROQ_API_KEY")
+        if not self.api_key:
+            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)
+
+    @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:
+            messages.extend(memory)
+        if context:
+            messages.append({"role": "system", "content": "Context: " + str(context)})
+        messages.append({"role": "user", "content": prompt})
+
+        # Call Groq API
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+        )
+
+        # Extract and return the response
+        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-0.0.1/semantio/llm/openai.py → semantio-0.0.2/semantio/llm/mistral.py

@@ -1,15 +1,15 @@
 from typing import List, Dict, Optional
 from .base_llm import BaseLLM
-import openai
+from mistralai import Mistral
 import os
 
-class OpenAILlm(BaseLLM):
-    def __init__(self, model: str = "gpt-4", api_key: Optional[str] = None):
+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("OPENAI_API_KEY")
+        self.api_key = api_key or os.getenv("MISTRAL_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
+            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 = []
@@ -19,8 +19,9 @@ class OpenAILlm(BaseLLM):
             messages.append({"role": "system", "content": "Context: " + str(context)})
         messages.append({"role": "user", "content": prompt})
 
-        response = openai.ChatCompletion.create(
+        response = self.client.chat.complete(
             model=self.model,
             messages=messages,
         )
-        return response.choices[0].message["content"]
+
+        return response.choices[0].message.content

semantio-0.0.2/semantio/llm/openai.py

@@ -0,0 +1,136 @@
+from typing import List, Dict, Optional
+from .base_llm import BaseLLM
+from openai import OpenAI
+import os
+import base64
+
+class OpenAILlm(BaseLLM):
+    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.")
+        self.client = OpenAI(api_key=self.api_key)
+
+    def generate(self, prompt: str, context: Optional[List[Dict]] = None, memory: Optional[List[Dict]] = None) -> str:
+        """
+        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 → semantio-0.0.2}/semantio.egg-info/PKG-INFO

@@ -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
@@ -94,7 +94,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 → semantio-0.0.2}/semantio.egg-info/SOURCES.txt

@@ -23,8 +23,10 @@ semantio/knowledge_base/vector_store.py
 semantio/llm/__init__.py
 semantio/llm/anthropic.py
 semantio/llm/base_llm.py
+semantio/llm/deepseek.py
+semantio/llm/gemini.py
 semantio/llm/groq.py
-semantio/llm/llama.py
+semantio/llm/mistral.py
 semantio/llm/openai.py
 semantio/storage/__init__.py
 semantio/storage/cloud_storage.py
@@ -34,7 +36,6 @@ semantio/tools/base_tool.py
 semantio/tools/crypto.py
 semantio/tools/duckduckgo.py
 semantio/tools/stocks.py
-semantio/tools/web_browser.py
 semantio/utils/__init__.py
 semantio/utils/config.py
 semantio/utils/date_utils.py

{semantio-0.0.1 → semantio-0.0.2}/semantio.egg-info/requires.txt

@@ -1,7 +1,8 @@
 openai
 anthropic
 groq
-langchain
+google-genai
+mistralai
 faiss-cpu
 pydantic
 requests
@@ -14,5 +15,3 @@ sentence-transformers
 fuzzywuzzy
 duckduckgo-search
 yfinance
-forex-python
-qrcode

{semantio-0.0.1 → semantio-0.0.2}/setup.py

@@ -2,8 +2,8 @@ from setuptools import setup, find_packages
 
 setup(
     name="semantio",
-    version="0.0.1",
-    description="A powerful SDK for building AI agents with RAG capabilities.",
+    version="0.0.2",
+    description="A powerful SDK for building AI agents",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
     author="Rakesh",
@@ -14,7 +14,8 @@ setup(
         "openai",
         "anthropic",
         "groq",
-        "langchain",
+        "google-genai",
+        "mistralai",
         "faiss-cpu",  # For vector storage
         "pydantic",   # For data validation
         "requests",   # For web tools
@@ -27,8 +28,6 @@ setup(
         "fuzzywuzzy", # For fuzzy string matching
         "duckduckgo-search", # For DuckDuckGo search
         "yfinance",   # For stock/crypto prices
-        "forex-python", # For currency conversion
-        "qrcode",     # For QR code generation
 
     ],
     classifiers=[

semantio-0.0.1/semantio/llm/anthropic.py

@@ -1,39 +0,0 @@
-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,
-    ):
-        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)
-
-    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})
-
-        # Call Anthropic API
-        response = self.client.completion(
-            model=self.model,
-            messages=messages,
-        )
-
-        # Extract and return the response
-        return response.choices[0].message.content

semantio-0.0.1/semantio/llm/base_llm.py

@@ -1,12 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Dict, Optional
-
-class BaseLLM(ABC):
-    @abstractmethod
-    def generate(
-        self,
-        prompt: str,
-        context: Optional[List[Dict]] = None,
-        memory: Optional[List[Dict]] = None,
-    ) -> str:
-        pass

semantio-0.0.1/semantio/llm/groq.py

@@ -1,39 +0,0 @@
-from typing import List, Dict, Optional
-from .base_llm import BaseLLM
-import groq
-import os
-
-class GroqLlm(BaseLLM):
-    def __init__(
-        self,
-        model: str = "mixtral-8x7b-32768",  # Default Groq model
-        api_key: Optional[str] = None,
-    ):
-        self.model = model
-        self.api_key = api_key or os.getenv("GROQ_API_KEY")
-        if not self.api_key:
-            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:
-        # Prepare messages for the Groq API
-        messages = []
-        if memory:
-            messages.extend(memory)
-        if context:
-            messages.append({"role": "system", "content": "Context: " + str(context)})
-        messages.append({"role": "user", "content": prompt})
-
-        # Call Groq API
-        response = self.client.chat.completions.create(
-            model=self.model,
-            messages=messages,
-        )
-
-        # Extract and return the response
-        return response.choices[0].message.content

semantio-0.0.1/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}"