semantio 0.0.2__tar.gz → 0.0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantio
-Version: 0.0.2
+Version: 0.0.3
 Summary: A powerful SDK for building AI agents
 Home-page: https://github.com/Syenah/semantio
 Author: Rakesh

{semantio-0.0.2 → semantio-0.0.3}/semantio/agent.py

@@ -21,24 +21,24 @@ import os
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class Assistant(BaseModel):
+class Agent(BaseModel):
     # -*- Agent settings
-    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.")
+    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.")
     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 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.")
+    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.")
     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 assistant.")
+    api: bool = Field(False, description="Whether to generate an API for the agent.")
     api_config: Optional[Dict] = Field(
         None,
         description="Configuration for the API (e.g., host, port, authentication).",
@@ -46,7 +46,7 @@ class Assistant(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.")
-    team: Optional[List['Assistant']] = Field(None, description="List of assistants in the team.")
+    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
@@ -125,7 +125,7 @@ class Assistant(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():
@@ -197,7 +197,7 @@ class Assistant(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)
@@ -214,10 +214,10 @@ class Assistant(BaseModel):
         stream: bool = False,
         markdown: bool = False,
         tools: Optional[List[BaseTool]] = None,
-        team: Optional[List['Assistant']] = None,
+        team: Optional[List['Agent']] = None,
         **kwargs,
     ) -> Union[str, Dict]:  # Add return type hint
-        """Print the assistant's response to the console and return it."""
+        """Print the agent's response to the console and return it."""
 
         if stream:
             # Handle streaming response
@@ -234,14 +234,14 @@ class Assistant(BaseModel):
 
 
     def _stream_response(self, message: str, markdown: bool = False, **kwargs) -> Iterator[str]:
-        """Stream the assistant's response."""
+        """Stream the agent'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 assistant."""
+        """Register a tool for the agent."""
         if self.tools is None:
             self.tools = []
         self.tools.append(tool)
@@ -256,7 +256,7 @@ class Assistant(BaseModel):
 
         # Create a prompt for the LLM
         prompt = f"""
-        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:
+        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:
 
         {self._get_tool_descriptions()}
 
@@ -290,7 +290,7 @@ class Assistant(BaseModel):
         """
         # Create a prompt for the LLM to analyze the query and select tools
         prompt = f"""
-        You are an AI assistant that helps analyze user queries and select the most appropriate tools.
+        You are an AI agent 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()}
@@ -324,8 +324,8 @@ class Assistant(BaseModel):
             return []
     
 
-    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."""
+    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 specified tools or team if provided
         if tools is not None:
             self.tools = tools
@@ -435,12 +435,12 @@ class Assistant(BaseModel):
         # 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:
+    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 assistant in team:
-            response = assistant.print_response(message, markdown=markdown, **kwargs)
-            responses.append(f"**{assistant.name}:**\n\n{response}")
+        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:
@@ -578,7 +578,7 @@ class Assistant(BaseModel):
         exit_on: Optional[List[str]] = None,
         **kwargs,
     ):
-        """Run the assistant in a CLI app."""
+        """Run the agent in a CLI app."""
         from rich.prompt import Prompt
 
         if message:
@@ -593,15 +593,15 @@ class Assistant(BaseModel):
             self.print_response(message=message, **kwargs)
 
     def _generate_api(self):
-        """Generate an API for the assistant if api=True."""
+        """Generate an API for the agent if api=True."""
         from .api.api_generator import APIGenerator
         self.api_generator = APIGenerator(self)
-        print(f"API generated for assistant '{self.name}'. Use `.run_api()` to start the API server.")
+        print(f"API generated for agent '{self.name}'. Use `.run_api()` to start the API server.")
 
     def run_api(self):
-        """Run the API server for the assistant."""
+        """Run the API server for the agent."""
         if not hasattr(self, 'api_generator'):
-            raise ValueError("API is not enabled for this assistant. Set `api=True` when initializing the assistant.")
+            raise ValueError("API is not enabled for this agent. Set `api=True` when initializing the agent.")
     
         # 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.2 → semantio-0.0.3}/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-0.0.2 → semantio-0.0.3}/semantio.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantio
-Version: 0.0.2
+Version: 0.0.3
 Summary: A powerful SDK for building AI agents
 Home-page: https://github.com/Syenah/semantio
 Author: Rakesh

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="semantio",
-    version="0.0.2",
+    version="0.0.3",
     description="A powerful SDK for building AI agents",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",