fyodorov-llm-agents 0.2.146__py3-none-any.whl → 0.2.148__py3-none-any.whl

fyodorov_llm_agents/agents/agent.py

@@ -1,15 +1,10 @@
 import os
 import re
-import requests
-import queue
-import threading
 import json
-import yaml
 from pydantic import BaseModel, HttpUrl
 from typing import Optional
-from openai import OpenAI as oai
 import litellm
-from fyodorov_llm_agents.tools.mcp_tool import MCPTool as Tool
+from fyodorov_llm_agents.tools.mcp_tool_service import MCPTool as ToolService
 from datetime import datetime
 
 MAX_NAME_LENGTH = 80
@@ -78,7 +73,7 @@ class Agent(BaseModel):
         #     'rag': self.rag,
         # }
 
-    def call_with_fn_calling(self, input: str = "", history = []) -> dict:
+    def call_with_fn_calling_old(self, input: str = "", history = []) -> dict:
         litellm.set_verbose = True
         model = self.model
         # Set environmental variable
@@ -106,7 +101,41 @@ class Agent(BaseModel):
             { "content": input, "role": "user"},
         ]
         print(f"Tools: {self.tools}")
-        tools = [tool.get_function() for tool in self.tools]
+        print(f"calling litellm with model {model}, messages: {messages}, max_retries: 0, history: {history}, base_url: {base_url}")
+        response = litellm.completion(model=model, messages=messages, max_retries=0, base_url=base_url)
+        print(f"Response: {response}")
+        answer = response.choices[0].message.content
+        print(f"Answer: {answer}")
+        return {
+            "answer": answer,
+
+        }
+    
+    def call_with_fn_calling(self, input: str = "", history = []) -> dict:
+        litellm.set_verbose = True
+        model = self.model
+        # Set environmental variable
+        if self.api_key.startswith('sk-'):
+            os.environ["OPENAI_API_KEY"] = self.api_key
+            self.api_url = "https://api.openai.com/v1"
+        elif self.api_key and self.api_key != '':
+            model = 'mistral/'+self.model
+            os.environ["MISTRAL_API_KEY"] = self.api_key
+            self.api_url = "https://api.mistral.ai/v1"
+        else:
+            print("Provider Ollama")
+            model = 'ollama/'+self.model
+            if self.api_url is None:
+                self.api_url = "https://api.ollama.ai/v1"
+
+        base_url = str(self.api_url.rstrip('/'))
+        messages: list[dict] = [
+            {"content": self.prompt, "role": "system"},
+            *history,
+            { "content": input, "role": "user"},
+        ]
+        print(f"Tools: {self.tools}")
+        tools = [ToolService.get_by_name_and_user_id(tool, self.user_id) for tool in self.tools]
         if tools and litellm.supports_function_calling(model=model):
             print(f"calling litellm with model {model}, tools: {tools}, messages: {messages}, max_retries: 0, history: {history}, base_url: {base_url}")
             response = litellm.completion(model=model, messages=messages, max_retries=0, tools=tools, tool_choice="auto", base_url=base_url)
@@ -114,14 +143,14 @@ class Agent(BaseModel):
             print(f"calling litellm with model {model}, messages: {messages}, max_retries: 0, history: {history}, base_url: {base_url}")
             response = litellm.completion(model=model, messages=messages, max_retries=0, base_url=base_url)
         print(f"Response: {response}")
-        tool_calls = []
-        if hasattr(response, 'tool_calls'):
-            tool_calls = response.tool_calls if response.tool_calls else []
-        if tool_calls:
-            for tool_call in tool_calls:
+        answer = response.choices[0].message
+        if hasattr(response, 'tool_calls') and response.tool_calls:
+            for tool_call in response.tool_calls:
                 print(f"Calling function {tool_call.function.name}")
                 function_args = json.loads(tool_call.function.arguments)
-                function_response = self.call_api(
+                tool = tools.get(tool_call.function.name)
+                ToolService.get
+                function_response =  self.call_api(
                     url=function_args["url"],
                     method=function_args["method"],
                     body=function_args["body"],
@@ -137,9 +166,7 @@ class Agent(BaseModel):
             response = litellm.completion(
                 model=model,
                 messages=messages,
-            )  # get a new response from the model where it can see the function response
-            print("\nSecond LLM response:\n", response)
-        answer = response.choices[0].message.content
+            )
         print(f"Answer: {answer}")
         return {
             "answer": answer,

fyodorov_llm_agents/tools/{mcp_tool.py → mcp_tool_model.py}

@@ -1,8 +1,10 @@
-from pydantic import BaseModel, HttpUrl, Field
+from pydantic import BaseModel, Field
 from typing import Optional, Dict, Any, Literal
 import re
 from datetime import datetime
 import yaml
+import requests
+import json
 
 APIUrlTypes = Literal['openapi']
 
@@ -71,6 +73,43 @@ class MCPTool(BaseModel):
         tool.validate()
         return tool
 
+    def call(self, args: dict) -> str:
+        if not self.api_url:
+            raise ValueError("MCP tool is missing an `api_url`")
+
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "Fyodorov-Agent/1.0",
+        }
+
+        # Handle authentication
+        if self.auth_method == "bearer":
+            token = self.auth_info.get("token")
+            if not token:
+                raise ValueError("Bearer token required but not provided in `auth_info`")
+            headers["Authorization"] = f"Bearer {token}"
+        elif self.auth_method == "basic":
+            user = self.auth_info.get("username")
+            pwd = self.auth_info.get("password")
+            if not user or not pwd:
+                raise ValueError("Basic auth requires `username` and `password` in `auth_info`")
+            auth = (user, pwd)
+        else:
+            auth = None  # anonymous access
+
+        try:
+            print(f"Calling MCP tool at {self.api_url} with args: {args}")
+            response = requests.post(self.api_url, json=args, headers=headers, auth=auth)
+            response.raise_for_status()
+            content_type = response.headers.get("Content-Type", "")
+            if "application/json" in content_type:
+                return json.dumps(response.json(), indent=2)
+            return response.text
+        except requests.RequestException as e:
+            print(f"Error calling MCP tool: {e}")
+            return f"Error calling tool: {e}"
+
+
     def to_dict(self) -> dict:
         """
         Convert this Pydantic model to a plain dict (e.g., for inserting into Supabase).

fyodorov_llm_agents/tools/mcp_tool_service.py

@@ -0,0 +1,133 @@
+from datetime import datetime
+from fyodorov_utils.config.supabase import get_supabase
+from fyodorov_llm_agents.tools.mcp_tool import MCPTool as ToolModel
+
+class MCPTool():
+    @staticmethod    
+    def create_in_db(access_token: str, tool: ToolModel, user_id: str) -> str:
+        try:
+            supabase = get_supabase(access_token)
+            tool_dict = tool.to_dict()
+            tool_dict['user_id'] = user_id
+            del tool_dict['id']
+            del tool_dict['created_at']
+            del tool_dict['updated_at']
+            print('creating tool in db', tool_dict)
+            result = supabase.table('mcp_tools').insert(tool_dict).execute()
+            tool_id = result.data[0]['id']
+            return tool_id
+        except Exception as e:
+            print('Error creating tool', str(e))
+            raise e
+
+    @staticmethod
+    def update_in_db(access_token: str, id: str, tool: ToolModel) -> dict:
+        if not id:
+            raise ValueError('Tool ID is required')
+        try:
+            supabase = get_supabase(access_token)
+            tool_dict = tool.to_dict()
+            print('updating tool in db', tool_dict)
+            result = supabase.table('mcp_tools').update(tool_dict).eq('id', id).execute()
+            return result.data[0]
+        except Exception as e:
+            print('An error occurred while updating tool:', id, str(e))
+            raise
+
+    @staticmethod
+    def delete_in_db(access_token: str, id: str) -> bool:
+        if not id:
+            raise ValueError('Tool ID is required')
+        try:
+            supabase = get_supabase(access_token)
+            result = supabase.table('mcp_tools').delete().eq('id', id).execute()
+            print('Deleted tool', result)
+            return True
+        except Exception as e:
+            print('Error deleting tool', str(e))
+            raise e
+
+    @staticmethod
+    def get_in_db(access_token: str, id: str) -> ToolModel:
+        if not id:
+            raise ValueError('Tool ID is required')
+        try:
+            supabase = get_supabase(access_token)
+            result = supabase.table('mcp_tools').select('*').eq('id', id).limit(1).execute()
+            tool_dict = result.data[0]
+            tool = ToolModel(**tool_dict)
+            return tool
+        except Exception as e:
+            print('Error fetching tool', str(e))
+            raise e
+
+    @staticmethod
+    def get_by_user_and_name_in_db(access_token: str, user_id: str, name: str) -> ToolModel:
+        try:
+            supabase = get_supabase(access_token)
+            result = supabase.table('mcp_tools').select('*').eq('user_id', user_id).eq('name', name).limit(1).execute()
+            tool_dict = result.data[0]
+            tool = ToolModel(**tool_dict)
+            return tool
+        except Exception as e:
+            print('Error fetching tool', str(e))
+            raise e
+
+    @staticmethod
+    def get_all_in_db(access_token: str, user_id: str = None, limit: int = 10, created_at_lt: datetime = datetime.now()) -> list[dict]:
+        try:
+            supabase = get_supabase(access_token)
+            print('getting tools from db for user', user_id)
+            tools = []
+            result = supabase.from_('mcp_tools') \
+                .select("*") \
+                .limit(limit) \
+                .lt('created_at', created_at_lt) \
+                .order('created_at', desc=True) \
+                .execute()
+            for tool in result.data:
+                tool["id"] = str(tool["id"])
+                tool["user_id"] = str(tool["user_id"])
+                tool["created_at"] = str(tool["created_at"])
+                tool["updated_at"] = str(tool["updated_at"])
+                if tool and (tool['public'] == True or (user_id and 'user_id' in tool and tool['user_id'] == user_id)):
+                    print('tool is public or belongs to user', tool)
+                    tools.append(tool)
+            print('got tools from db', len(tools))
+            return tools
+        except Exception as e:
+            print('Error fetching tools', str(e))
+            raise e
+
+    @staticmethod
+    def get_tool_agents(access_token: str, id: str) -> list[int]:
+        if not id:
+            raise ValueError('Tool ID is required')
+        try:
+            supabase = get_supabase(access_token)
+            result = supabase.table('agent_mcp_tool').select('*').eq('mcp_tool_id', id).execute()
+            tool_agents = [item['agent_id'] for item in result.data if 'agent_id' in item]
+            return tool_agents
+        except Exception as e:
+            print('Error fetching tool agents', str(e))
+            raise
+
+    @staticmethod
+    def set_tool_agents(access_token: str, id: str, agent_ids: list[int]) -> list[int]:
+        if not id:
+            raise ValueError('Tool ID is required')
+        try:
+            supabase = get_supabase(access_token)
+            for agent_id in agent_ids:
+                # Check if agent is valid and exists in the database
+                agent_result = supabase.table('agents').select('*').eq('id', agent_id).limit(1).execute()
+                if not agent_result.data:
+                    print(f"Agent with ID {agent_id} does not exist.")
+                    continue
+                # Insert the agent-tool relationship
+                supabase.table('agent_mcp_tool').insert({'mcp_tool_id': id, 'agent_id': agent_id}).execute()
+            print('Inserted tool agents', agent_ids)
+            return agent_ids
+        except Exception as e:
+            print('Error setting tool agents', str(e))
+            raise

{fyodorov_llm_agents-0.2.146.dist-info → fyodorov_llm_agents-0.2.148.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fyodorov_llm_agents
-Version: 0.2.146
+Version: 0.2.148
 Summary: LLM agents for the Fyodorov AI suite
 Author-email: Daniel Ransom <02masseur.alibis@icloud.com>
 Project-URL: Homepage, https://github.com/FyodorovAI/fyodorov-llm-agents

fyodorov_llm_agents-0.2.148.dist-info/RECORD

@@ -0,0 +1,9 @@
+fyodorov_llm_agents/agents/agent.py,sha256=NbjiyydsrNUdEQYZ_rR1YpAZ-oqRZqxKEwStWxOkxpE,8010
+fyodorov_llm_agents/agents/openai.py,sha256=FA5RS7yn3JwvFA8PXju60XSYC_2oUZFNgBUzeIYtGv0,1154
+fyodorov_llm_agents/tools/mcp_tool_model.py,sha256=i7oFZReVGZsHN2K8T7mCAGF4t92wMMIR9mCkRHUgKsI,4413
+fyodorov_llm_agents/tools/mcp_tool_service.py,sha256=MWf-wKu0iEUd7K_iXEClAqr2kB9gTJPlXoVnTva4DSQ,5558
+fyodorov_llm_agents/tools/tool.py,sha256=HyOk0X_3XE23sa8J-8UZx657tJ0sxwZWMbA4OPxXU6E,7940
+fyodorov_llm_agents-0.2.148.dist-info/METADATA,sha256=BO7MA-li_5Lt07aUfM2_Wx7rM1Lf-zURXMbDXAnad24,552
+fyodorov_llm_agents-0.2.148.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+fyodorov_llm_agents-0.2.148.dist-info/top_level.txt,sha256=4QOslsBp8Gh7ng25DceA7fHp4KguTIdAxwURz97gH-g,20
+fyodorov_llm_agents-0.2.148.dist-info/RECORD,,

{fyodorov_llm_agents-0.2.146.dist-info → fyodorov_llm_agents-0.2.148.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.1)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

fyodorov_llm_agents-0.2.146.dist-info/RECORD

@@ -1,8 +0,0 @@
-fyodorov_llm_agents/agents/agent.py,sha256=Lb9wBH1OnDvzYAOc4LFg4MWoMJwburC_wdxSygEy5KY,6781
-fyodorov_llm_agents/agents/openai.py,sha256=FA5RS7yn3JwvFA8PXju60XSYC_2oUZFNgBUzeIYtGv0,1154
-fyodorov_llm_agents/tools/mcp_tool.py,sha256=E-LAx2rYxG4ujBtqzeHDbHLxanlT9qnjdal7aMvhYEA,2899
-fyodorov_llm_agents/tools/tool.py,sha256=HyOk0X_3XE23sa8J-8UZx657tJ0sxwZWMbA4OPxXU6E,7940
-fyodorov_llm_agents-0.2.146.dist-info/METADATA,sha256=X2pNnm3HeOABgNvhftOc2wa17nEO8uirCcxwCngPGV4,552
-fyodorov_llm_agents-0.2.146.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-fyodorov_llm_agents-0.2.146.dist-info/top_level.txt,sha256=4QOslsBp8Gh7ng25DceA7fHp4KguTIdAxwURz97gH-g,20
-fyodorov_llm_agents-0.2.146.dist-info/RECORD,,