entity details

superagi/apm/knowledge_handler.py

@@ -0,0 +1,133 @@
+from sqlalchemy.orm import Session
+from superagi.models.events import Event
+from superagi.models.knowledges import Knowledges
+from sqlalchemy import Integer, or_, label, case, and_
+from fastapi import HTTPException
+from typing import List, Dict, Union, Any
+from sqlalchemy.sql import func
+from sqlalchemy.orm import aliased
+from superagi.models.agent_config import AgentConfiguration
+import pytz
+
+
+class KnowledgeHandler:
+    def __init__(self, session: Session, organisation_id: int):
+        self.session = session
+        self.organisation_id = organisation_id
+
+
+    def get_knowledge_usage_by_name(self, knowledge_name: str) -> Dict[str, Dict[str, int]]:
+
+        is_knowledge_valid = self.session.query(Knowledges.id).filter_by(name=knowledge_name).filter(Knowledges.organisation_id == self.organisation_id).first()
+        if not is_knowledge_valid:
+            raise HTTPException(status_code=404, detail="Knowledge not found")
+        EventAlias = aliased(Event)
+
+        knowledge_used_event = self.session.query(
+            Event.event_property['knowledge_name'].label('knowledge_name'),
+            func.count(Event.agent_id.distinct()).label('knowledge_unique_agents')
+        ).filter(
+            Event.event_name == 'knowledge_picked',
+            Event.org_id == self.organisation_id,
+            Event.event_property['knowledge_name'].astext == knowledge_name
+        ).group_by(
+            Event.event_property['knowledge_name']
+        ).first()
+
+        if knowledge_used_event is None:
+            return {}
+
+        knowledge_data = {
+                'knowledge_unique_agents': knowledge_used_event.knowledge_unique_agents,
+                'knowledge_calls': self.session.query(
+                    EventAlias
+                ).filter(
+                    EventAlias.event_property['tool_name'].astext == 'knowledgesearch',
+                    EventAlias.event_name == 'tool_used',
+                    EventAlias.org_id == self.organisation_id,
+                    EventAlias.agent_id.in_(self.session.query(Event.agent_id).filter(
+                        Event.event_name == 'knowledge_picked',
+                        Event.org_id == self.organisation_id,
+                        Event.event_property['knowledge_name'].astext == knowledge_name
+                    ))
+                ).count()
+            }
+
+        return knowledge_data
+
+
+    def get_knowledge_events_by_name(self, knowledge_name: str) -> List[Dict[str, Union[str, int]]]:
+
+        is_knowledge_valid = self.session.query(Knowledges.id).filter_by(name=knowledge_name).filter(Knowledges.organisation_id == self.organisation_id).first()
+
+        if not is_knowledge_valid:
+            raise HTTPException(status_code=404, detail="Knowledge not found")
+
+        event_knowledge_picked = self.session.query(
+            Event.agent_id,
+            label('created_at', func.max(Event.created_at)),
+            label('event_name', func.max(Event.event_name))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            Event.event_name == 'knowledge_picked',
+            Event.event_property['knowledge_name'].astext == knowledge_name
+        ).group_by(Event.agent_id).subquery()
+
+        event_run = self.session.query(
+            Event.agent_id,
+            label('tokens_consumed', func.sum(Event.event_property['tokens_consumed'].astext.cast(Integer))),
+            label('calls', func.sum(Event.event_property['calls'].astext.cast(Integer)))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            or_(Event.event_name == 'run_completed', Event.event_name == 'run_iteration_limit_crossed')
+        ).group_by(Event.agent_id).subquery()
+
+        event_run_created = self.session.query(
+            Event.agent_id,
+            label('agent_execution_name', func.max(Event.event_property['agent_execution_name'].astext))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            Event.event_name == 'run_created'
+        ).group_by(Event.agent_id).subquery()
+
+        event_agent_created = self.session.query(
+            Event.agent_id,
+            label('agent_name', func.max(Event.event_property['agent_name'].astext)),
+            label('model', func.max(Event.event_property['model'].astext))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            Event.event_name == 'agent_created'
+        ).group_by(Event.agent_id).subquery()
+
+
+        result = self.session.query(
+            event_knowledge_picked.c.agent_id,
+            event_knowledge_picked.c.created_at,
+            event_knowledge_picked.c.event_name,
+            event_run.c.tokens_consumed,
+            event_run.c.calls,
+            event_run_created.c.agent_execution_name,
+            event_agent_created.c.agent_name,
+            event_agent_created.c.model
+        ).join(
+            event_run, event_knowledge_picked.c.agent_id == event_run.c.agent_id
+        ).join(
+            event_run_created, event_knowledge_picked.c.agent_id == event_run_created.c.agent_id
+        ).join(
+            event_agent_created, event_knowledge_picked.c.agent_id == event_agent_created.c.agent_id
+        ).all()
+
+        user_timezone = AgentConfiguration.get_agent_config_by_key_and_agent_id(session= self.session,key= 'user_timezone', agent_id= Event.agent_id)
+        if user_timezone.value is None:
+            user_timezone.value = 'GMT'
+
+        return [{
+            'agent_id': row.agent_id,
+            'created_at': row.created_at.astimezone(pytz.timezone(user_timezone.value)).strftime("%d %B %Y %H:%M"),
+            'event_name': row.event_name,
+            'tokens_consumed': row.tokens_consumed,
+            'calls': row.calls,
+            'agent_execution_name': row.agent_execution_name,
+            'agent_name': row.agent_name,
+            'model': row.model
+        } for row in result]

superagi/apm/tools_handler.py

@@ -1,12 +1,15 @@
-from typing import List, Dict
-
-from sqlalchemy import func
+from typing import List, Dict, Union
+from sqlalchemy import func, distinct
 from sqlalchemy.orm import Session
-
+from sqlalchemy import Integer
+from fastapi import HTTPException
 from superagi.models.events import Event
 from superagi.models.tool import Tool
 from superagi.models.toolkit import Toolkit
-
+from sqlalchemy import or_
+from sqlalchemy.sql import label
+from superagi.models.agent_config import AgentConfiguration
+import pytz
 
 class ToolsHandler:
     def __init__(self, session: Session, organisation_id: int):
@@ -54,4 +57,123 @@ def calculate_tool_usage(self) -> List[Dict[str, int]]:
             'toolkit': tool_and_toolkit.get(row.tool_name, None)
         } for row in result]
 
-        return tool_usage
+        return tool_usage
+
+    def get_tool_usage_by_name(self, tool_name: str) -> Dict[str, Dict[str, int]]:
+        is_tool_name_valid = self.session.query(Tool).filter_by(name=tool_name).first()
+
+        if not is_tool_name_valid:
+            raise HTTPException(status_code=404, detail="Tool not found")
+        formatted_tool_name = tool_name.lower().replace(" ", "")
+
+        tool_used_event = self.session.query(
+            Event.event_property['tool_name'].label('tool_name'), 
+            func.count(Event.id).label('tool_calls'),
+            func.count(distinct(Event.agent_id)).label('tool_unique_agents')
+        ).filter(
+            Event.event_name == 'tool_used', 
+            Event.org_id == self.organisation_id,
+            Event.event_property['tool_name'].astext == formatted_tool_name
+        ).group_by(
+            Event.event_property['tool_name']
+        ).first()
+
+        if tool_used_event is None:
+            return {}
+
+        tool_data = {
+                'tool_calls': tool_used_event.tool_calls,
+                'tool_unique_agents': tool_used_event.tool_unique_agents
+            }
+
+        return tool_data
+
+    def get_tool_events_by_name(self, tool_name: str) -> List[Dict[str, Union[str, int, List[str]]]]:    
+
+        is_tool_name_valid = self.session.query(Tool).filter_by(name=tool_name).first()
+
+        if not is_tool_name_valid:
+            raise HTTPException(status_code=404, detail="Tool not found")
+
+        formatted_tool_name = tool_name.lower().replace(" ", "")
+
+        event_tool_used = self.session.query(
+            Event.agent_id,
+            label('created_at', func.max(Event.created_at)),
+            label('event_name', func.max(Event.event_name))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            Event.event_name == 'tool_used',
+            Event.event_property['tool_name'].astext == formatted_tool_name
+        ).group_by(Event.agent_id).subquery()
+
+        event_run = self.session.query(
+            Event.agent_id,
+            label('tokens_consumed', func.sum(Event.event_property['tokens_consumed'].astext.cast(Integer))),
+            label('calls', func.sum(Event.event_property['calls'].astext.cast(Integer)))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            or_(Event.event_name == 'run_completed', Event.event_name == 'run_iteration_limit_crossed')
+        ).group_by(Event.agent_id).subquery()
+
+        event_run_created = self.session.query(
+            Event.agent_id,
+            label('agent_execution_name', func.max(Event.event_property['agent_execution_name'].astext))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            Event.event_name == 'run_created'
+        ).group_by(Event.agent_id).subquery()
+
+        event_agent_created = self.session.query(
+            Event.agent_id,
+            label('agent_name', func.max(Event.event_property['agent_name'].astext)),
+            label('model', func.max(Event.event_property['model'].astext))
+        ).filter(
+            Event.org_id == self.organisation_id,
+            Event.event_name == 'agent_created'
+        ).group_by(Event.agent_id).subquery()
+
+        other_tools = self.session.query(
+            Event.agent_id,
+            func.array_agg(distinct(Event.event_property['tool_name'].astext)).label('other_tools')
+        ).filter(
+            Event.org_id == self.organisation_id,
+            Event.event_name == 'tool_used',
+            Event.event_property['tool_name'].astext != formatted_tool_name
+        ).group_by(Event.agent_id).subquery()
+
+        result = self.session.query(
+            event_tool_used.c.agent_id,
+            event_tool_used.c.created_at,
+            event_tool_used.c.event_name,
+            event_run.c.tokens_consumed,
+            event_run.c.calls,
+            event_run_created.c.agent_execution_name,
+            event_agent_created.c.agent_name,
+            event_agent_created.c.model,
+            other_tools.c.other_tools
+        ).join(
+            event_run, event_tool_used.c.agent_id == event_run.c.agent_id
+        ).join(
+            event_run_created, event_tool_used.c.agent_id == event_run_created.c.agent_id
+        ).join(
+            event_agent_created, event_tool_used.c.agent_id == event_agent_created.c.agent_id
+        ).join(
+            other_tools, event_tool_used.c.agent_id == other_tools.c.agent_id, isouter=True
+        ).all()
+
+        user_timezone = AgentConfiguration.get_agent_config_by_key_and_agent_id(session= self.session,key= 'user_timezone', agent_id= Event.agent_id)
+        if user_timezone.value is None:
+            user_timezone.value = 'GMT'
+
+        return [{
+            'agent_id': row.agent_id,
+            'created_at': row.created_at.astimezone(pytz.timezone(user_timezone.value)).strftime("%d %B %Y %H:%M"),
+            'event_name': row.event_name,
+            'tokens_consumed': row.tokens_consumed,
+            'calls': row.calls,
+            'agent_execution_name': row.agent_execution_name,
+            'agent_name': row.agent_name,
+            'model': row.model,
+            'other_tools': row.other_tools
+        } for row in result]

superagi/controllers/agent.py

@@ -132,18 +132,26 @@ def create_agent_with_config(agent_with_config: AgentConfigInput,
 
     agent = db.session.query(Agent).filter(Agent.id == db_agent.id,  ).first()
     organisation = agent.get_agent_organisation(db.session)
-    EventHandler(session=db.session).create_event('run_created', {'agent_execution_id': execution.id,
-                                                                  'agent_execution_name':  execution.name}, db_agent.id,
-
-                                                  organisation.id if organisation else 0),
-    EventHandler(session=db.session).create_event('agent_created', {'agent_name': agent_with_config.name,
-
-                                                                    'model': agent_with_config.model}, db_agent.id,
-
+
+    EventHandler(session=db.session).create_event('run_created', 
+                                                  {'agent_execution_id': execution.id,
+                                                   'agent_execution_name':  execution.name},
+                                                    db_agent.id,
+                                                    organisation.id if organisation else 0),
+
+    if agent_with_config.knowledge:
+        knowledge_name = db.session.query(Knowledges.name).filter(Knowledges.id == agent_with_config.knowledge).first()[0]
+        EventHandler(session=db.session).create_event('knowledge_picked', 
+                                                      {'knowledge_name': knowledge_name},
+                                                      db_agent.id, 
+                                                      organisation.id if organisation else 0)
+
+    EventHandler(session=db.session).create_event('agent_created', 
+                                                  {'agent_name': agent_with_config.name,
+                                                   'model': agent_with_config.model}, 
+                                                  db_agent.id,
                                                   organisation.id if organisation else 0)
 
-    # execute_agent.delay(execution.id, datetime.now())
-
     db.session.commit()
 
     return {

superagi/controllers/agent_execution.py

@@ -24,6 +24,7 @@
 from superagi.apm.event_handler import EventHandler
 from superagi.controllers.tool import ToolOut
 from superagi.models.agent_config import AgentConfiguration
+from superagi.models.knowledges import Knowledges
 
 router = APIRouter()
 
@@ -122,11 +123,21 @@ def create_agent_execution(agent_execution: AgentExecutionIn,
                                                                      agent_execution_configs=agent_execution_configs)
 
     organisation = agent.get_agent_organisation(db.session)
-    EventHandler(session=db.session).create_event('run_created', {'agent_execution_id': db_agent_execution.id,'agent_execution_name':db_agent_execution.name},
-                                 agent_execution.agent_id, organisation.id if organisation else 0)
-
-    Models.api_key_from_configurations(session=db.session, organisation_id=organisation.id)
-
+    agent_execution_knowledge = AgentConfiguration.get_agent_config_by_key_and_agent_id(session= db.session, key= 'knowledge', agent_id= agent_execution.agent_id)
+
+    EventHandler(session=db.session).create_event('run_created', 
+                                                  {'agent_execution_id': db_agent_execution.id,
+                                                   'agent_execution_name':db_agent_execution.name},
+                                                   agent_execution.agent_id, 
+                                                   organisation.id if organisation else 0)
+    if agent_execution_knowledge:
+        knowledge_name = Knowledges.get_knowledge_from_id(db.session, int(agent_execution_knowledge.value)).name
+        if knowledge_name is not None:
+            EventHandler(session=db.session).create_event('knowledge_picked', 
+                                                        {'knowledge_name': knowledge_name},
+                                                        agent_execution.agent_id, 
+                                                        organisation.id if organisation else 0)
+
     if db_agent_execution.status == "RUNNING":
       execute_agent.delay(db_agent_execution.id, datetime.now())
 
@@ -188,8 +199,19 @@ def create_agent_run(agent_execution: AgentRunIn, Authorize: AuthJWT = Depends(c
                                                                      agent_execution_configs = agent_execution_configs)
 
     organisation = agent.get_agent_organisation(db.session)
-    EventHandler(session=db.session).create_event('run_created', {'agent_execution_id': db_agent_execution.id,'agent_execution_name':db_agent_execution.name},
-                                 agent_execution.agent_id, organisation.id if organisation else 0)
+    EventHandler(session=db.session).create_event('run_created',
+                                                  {'agent_execution_id': db_agent_execution.id,
+                                                    'agent_execution_name':db_agent_execution.name},
+                                                    agent_execution.agent_id, 
+                                                    organisation.id if organisation else 0)
+    agent_execution_knowledge = AgentConfiguration.get_agent_config_by_key_and_agent_id(session= db.session, key= 'knowledge', agent_id= agent_execution.agent_id)
+    if agent_execution_knowledge:
+        knowledge_name = Knowledges.get_knowledge_from_id(db.session, int(agent_execution_knowledge.value)).name
+        if knowledge_name is not None:
+            EventHandler(session=db.session).create_event('knowledge_picked', 
+                                                        {'knowledge_name': knowledge_name},
+                                                        agent_execution.agent_id, 
+                                                        organisation.id if organisation else 0)
 
     if db_agent_execution.status == "RUNNING":
       execute_agent.delay(db_agent_execution.id, datetime.now())