versionhq 1.1.11.8__py3-none-any.whl → 1.1.12.2__py3-none-any.whl

versionhq/memory/model.py

@@ -1,7 +1,53 @@
+import datetime
 from typing import Any, Dict, List, Optional
 
 from versionhq.storage.rag_storage import RAGStorage
 from versionhq.storage.ltm_sqlite_storage import LTMSQLiteStorage
+from versionhq._utils.logger import Logger
+
+
+class MemoryData:
+    """
+    A class to store structured data to store in the memory.
+    """
+    def __init__(
+        self,
+        agent: Optional[str] = None, # task execution agent (core)
+        task_description: Optional[str] = None,
+        task_output: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None
+    ):
+        self.agent = agent
+        self.task_description = task_description
+        self.task_output = task_output
+
+        if config:
+            for k, v in config.items():
+                setattr(self, k, str(v))
+
+
+
+class MemoryMetadata:
+    """
+     A class to store structured metadata to store in the memory.
+    """
+
+    def __init__(
+        self,
+        eval_criteria: Optional[str] = None,
+        score: Optional[int | float] = None,
+        suggestion: Optional[str] = None,
+        eval_by: Optional[str] = None, # task evaluator agent
+        config: Optional[Dict[str, Any]] = None
+    ):
+        self.eval_criteria = eval_criteria
+        self.score = score
+        self.suggestion = suggestion
+        self.eval_by = eval_by
+
+        if config:
+            for k, v in config.items():
+                setattr(self, k, str(v))
 
 
 class Memory:
@@ -13,28 +59,46 @@ class Memory:
         self.storage = storage
 
 
-    def save(self, value: Any, metadata: Optional[Dict[str, Any]] = None, agent: Optional[str] = None) -> None:
-        metadata = metadata or {}
+    def save(
+            self,
+            data: MemoryData | Dict[str, Any],
+            metadata: Optional[MemoryMetadata | Dict[str, Any]] = None,
+            agent: Optional[str] = None
+        ) -> None:
+
+        """
+        Create a dict for data and metadata without empty values before storing them in the given storage.
+        """
+
+        if not data:
+            Logger(verbose=True).log(level="error", message="Missing data to store. Add either dict or MemoryData object", color="red")
+            return None
 
-        if agent:
-            metadata["agent"] = agent
-        self.storage.save(value, metadata)
+        metadata_dict = metadata if isinstance(metadata, dict) else metadata.__dict__ if isinstance(metadata, MemoryMetadata) else dict()
+        metadata_dict = {k: v for k, v in metadata_dict.items() if v} # remove empty values
+        data_dict = data if isinstance(data, dict) else data.__dict__ if isinstance(data, MemoryData) else dict()
+        data_dict = {k: v for k, v in data_dict.items() if v}
+
+        if agent and data_dict["agent"] is None:
+            data_dict["agent"] = agent
+
+        if metadata_dict:
+            self.storage.save(data=data_dict, metadata=metadata_dict)
+        else:
+            self.storage.save(data=data_dict)
 
 
     def search(self, query: str, limit: int = 3, score_threshold: float = 0.35) -> List[Any]:
         return self.storage.search(query=query, limit=limit, score_threshold=score_threshold)
 
 
+class MemoryItem:
+    """
+    A class to store item to be saved in either long term memory or short term memory.
+    """
 
-class ShortTermMemoryItem:
-    def __init__(
-        self,
-        data: Any,
-        agent: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ):
+    def __init__(self, data: MemoryData = None, metadata: Optional[MemoryMetadata] = None):
         self.data = data
-        self.agent = agent
         self.metadata = metadata if metadata is not None else {}
 
 
@@ -70,12 +134,22 @@ class ShortTermMemory(Memory):
         super().__init__(storage)
 
 
-    def save(self, value: Any, metadata: Optional[Dict[str, Any]] = None, agent: Optional[str] = None) -> None:
-        item = ShortTermMemoryItem(data=value, metadata=metadata, agent=agent)
+    def save(
+            self,
+            task_description: str = None,
+            task_output: str = None,
+            agent: Optional[str] = None,
+            data: Optional[MemoryData] = None,
+            metadata: Optional[MemoryMetadata] = None
+        ) -> None:
+
+        data = data if data else MemoryData(task_description=task_description, task_output=task_output, agent=agent)
+        item = MemoryItem(data=data, metadata=metadata)
+
         if self.memory_provider == "mem0":
-            item.data = f"Remember the following insights from Agent run: {item.data}"
+            item.data.task_output = f"Remember the following insights from Agent run: {item.data.task_output}"
 
-        super().save(value=item.data, metadata=item.metadata, agent=item.agent)
+        super().save(data=item.data.__dict__, metadata=item.metadata.__dict__ if item.metadata else {})
 
 
     def search(self, query: str, limit: int = 3, score_threshold: float = 0.35,):
@@ -89,29 +163,11 @@ class ShortTermMemory(Memory):
             raise Exception(f"An error occurred while resetting the short-term memory: {str(e)}")
 
 
-
-class LongTermMemoryItem:
-    def __init__(
-        self,
-        agent: str,
-        task: str,
-        datetime: str,
-        quality: Optional[int | float] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ):
-        self.task = task
-        self.agent = agent
-        self.quality = quality
-        self.datetime = datetime
-        self.metadata = metadata if metadata is not None else {}
-
-
-
 class LongTermMemory(Memory):
     """
     A class for managing cross runs data related to overall task executions.
     - Type: ltm
-    - Storage: LTMSQLiteStorage
+    - Storage: LTMSQLiteStorage | RAGStorage
     """
 
     def __init__(self, storage=None, path=None):
@@ -121,19 +177,25 @@ class LongTermMemory(Memory):
         super().__init__(storage)
 
 
-    def save(self, item: LongTermMemoryItem) -> None:
-        metadata = item.metadata
-        metadata.update({ "agent": item.agent })
-        self.storage.save(
-            task_description=item.task,
-            score=metadata["quality"],
-            metadata=metadata,
-            datetime=item.datetime,
-        )
+    def save(
+            self,
+            task_description: str = None,
+            task_output: str = None,
+            agent: Optional[str] = None,
+            data: Optional[MemoryData] = None,
+            metadata: Optional[MemoryMetadata] = None
+        ) -> None:
+
+        data = data if data else MemoryData(task_description=task_description, task_output=task_output, agent=agent)
+        item = MemoryItem(data=data, metadata=metadata)
+        super().save(data=item.data, metadata=item.metadata)
 
 
-    def search(self, task: str, latest_n: int = 3) -> List[Dict[str, Any]]:
-        return self.storage.load(task, latest_n)
+    def search(self, query: str, latest_n: int = 3) -> List[Dict[str, Any]]:
+        """
+        Query the storage and return the results up to latest_n.
+        """
+        return self.storage.load(query=query, latest_n=latest_n)
 
 
     def reset(self) -> None:

versionhq/storage/ltm_sqlite_storage.py

@@ -1,4 +1,5 @@
 import json
+import datetime
 import sqlite3
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -27,88 +28,77 @@ class LTMSQLiteStorage:
         """
         Initializes the SQLite database and creates LTM table
         """
+
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
                 cursor.execute(
-                    """
+                """
                     CREATE TABLE IF NOT EXISTS long_term_memories (
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        task_description TEXT,
-                        metadata TEXT,
-                        datetime TEXT,
-                        score REAL
+                        datetime REAL,
+                        data TEXT,
+                        metadata TEXT
                     )
                 """
                 )
-
                 conn.commit()
 
         except sqlite3.Error as e:
-            self._logger.log(
-                level="error",
-                message=f"MEMORY ERROR: An error occurred during database initialization: {str(e)}",
-                color="red",
-            )
+            self._logger.log(level="error", message=f"MEMORY ERROR: An error occurred during database initialization: {str(e)}", color="red")
+
 
-    def save(self, task_description: str, metadata: Dict[str, Any], datetime: str, score: int | float) -> None:
+    def save(self, data: Dict[str, Any] | str, metadata: Optional[Dict[str, Any]] = {}) -> None:
         """
         Saves data to the LTM table with error handling.
         """
+        data = data if isinstance(data, dict) else dict(data=data)
+
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
                 cursor.execute(
-                    """
-                INSERT INTO long_term_memories (task_description, metadata, datetime, score)
-                VALUES (?, ?, ?, ?)
+            """
+                INSERT INTO long_term_memories (datetime, data, metadata)
+                VALUES (?, ?, ?)
             """,
-                    (task_description, json.dumps(metadata), datetime, score),
+                    (datetime.datetime.now().timestamp(), json.dumps(data), json.dumps(metadata)),
                 )
                 conn.commit()
         except sqlite3.Error as e:
-            self._logger.log(
-                level="error",
-                message=f"MEMORY ERROR: An error occurred while saving to LTM: {str(e)}",
-                color="red",
-            )
+            self._logger.log(level="error", message=f"MEMORY ERROR: An error occurred while saving to LTM: {str(e)}", color="red")
 
 
-    def load(self, task_description: str, latest_n: int) -> Optional[List[Dict[str, Any]]]:
+    def load(self, query: str, latest_n: int) -> Optional[List[Dict[str, Any]]]:
         """
-        Queries the LTM table by task description with error handling.
+        Queries the data row in the storage with error handling.
         """
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
                 cursor.execute(
-                    f"""
-                    SELECT metadata, datetime, score
+                f"""
+                    SELECT datetime, data, metadata
                     FROM long_term_memories
-                    WHERE task_description = ?
-                    ORDER BY datetime DESC, score ASC
+                    WHERE data LIKE '%{query}%'
+                    ORDER BY datetime
                     LIMIT {latest_n}
-                """,
-                    (task_description,),
+                """
                 )
                 rows = cursor.fetchall()
                 if rows:
                     return [
                         {
-                            "metadata": json.loads(row[0]),
-                            "datetime": row[1],
-                            "score": row[2],
+                            "datetime": row[0],
+                            "data": json.loads(row[1]),
+                            "metadata": json.loads(row[2]),
                         }
                         for row in rows
                     ]
 
         except sqlite3.Error as e:
-            self._logger.log(
-                level="error",
-                message=f"MEMORY ERROR: An error occurred while querying LTM: {e}",
-                color="red",
-            )
-        return None
+            self._logger.log(level="error", message=f"MEMORY ERROR: An error occurred while querying LTM: {e}",color="red")
+            return None
 
 
     def reset(self) -> None:
@@ -123,9 +113,5 @@ class LTMSQLiteStorage:
                 conn.commit()
 
         except sqlite3.Error as e:
-            self._logger.log(
-                level="error",
-                message=f"MEMORY ERROR: An error occurred while deleting all rows in LTM: {str(e)}",
-                color="red",
-            )
+            self._logger.log(level="error", message=f"MEMORY ERROR: An error occurred while deleting all rows in LTM: {str(e)}", color="red")
         return None

versionhq/storage/mem0_storage.py

@@ -47,7 +47,7 @@ class Mem0Storage(Storage):
         return role.replace("\n", "").replace(" ", "_").replace("/", "_")
 
 
-    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
+    def save(self, value: Dict[str, Any] | str, metadata: Dict[str, Any]) -> None:
         user_id = self._get_user_id()
         agent_name = self._get_agent_name()
 

versionhq/storage/rag_storage.py

@@ -163,11 +163,32 @@ class RAGStorage(BaseRAGStorage):
         return f"{base_path}/{file_name}"
 
 
-    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
+    def _create_default_embedding_function(self):
+        from chromadb.utils.embedding_functions.openai_embedding_function import (
+            OpenAIEmbeddingFunction,
+        )
+
+        return OpenAIEmbeddingFunction(
+            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
+        )
+
+
+    def _generate_embedding(self, text: str, metadata: Optional[Dict[str, Any]]) -> None:
+        if not hasattr(self, "app") or not hasattr(self, "collection"):
+            self._initialize_app()
+
+        if metadata:
+            self.collection.add(documents=[text], metadatas=[metadata, ], ids=[str(uuid.uuid4())])
+
+        else:
+            self.collection.add(documents=[text], ids=[str(uuid.uuid4())])
+
+
+    def save(self, data: Dict[str, Any] | str, metadata: Optional[Dict[str, Any]] = dict()) -> None:
         if not hasattr(self, "app") or not hasattr(self, "collection"):
             self._initialize_app()
         try:
-            self._generate_embedding(value, metadata)
+            self._generate_embedding(text=str(data), metadata=metadata)
         except Exception as e:
             logging.error(f"Error during {self.type} save: {str(e)}")
 
@@ -197,17 +218,6 @@ class RAGStorage(BaseRAGStorage):
             return []
 
 
-    def _generate_embedding(self, text: str, metadata: Dict[str, Any]) -> None:
-        if not hasattr(self, "app") or not hasattr(self, "collection"):
-            self._initialize_app()
-
-        self.collection.add(
-            documents=[text],
-            metadatas=[metadata or {}],
-            ids=[str(uuid.uuid4())],
-        )
-
-
     def reset(self) -> None:
         try:
             if self.app:
@@ -220,12 +230,3 @@ class RAGStorage(BaseRAGStorage):
                 pass
             else:
                 raise Exception(f"An error occurred while resetting the {self.type} memory: {e}")
-
-    def _create_default_embedding_function(self):
-        from chromadb.utils.embedding_functions.openai_embedding_function import (
-            OpenAIEmbeddingFunction,
-        )
-
-        return OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )

versionhq/storage/task_output_storage.py

@@ -7,7 +7,7 @@ from versionhq._utils.logger import Logger
 from versionhq.storage.utils import fetch_db_storage_path
 
 storage_path = fetch_db_storage_path()
-default_db_name = "task_outputs"
+default_db_name = "task_output"
 
 
 class TaskOutputSQLiteStorage:
@@ -31,7 +31,7 @@ class TaskOutputSQLiteStorage:
                 cursor = conn.cursor()
                 cursor.execute(
                     """
-                    CREATE TABLE IF NOT EXISTS task_outputs (
+                    CREATE TABLE IF NOT EXISTS task_output (
                         task_id TEXT PRIMARY KEY,
                         output JSON,
                         task_index INTEGER,
@@ -52,7 +52,7 @@ class TaskOutputSQLiteStorage:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
                 cursor.execute(
-                        """INSERT OR REPLACE INTO task_outputs
+                        """INSERT OR REPLACE INTO task_output
                             (task_id, output, task_index, inputs, was_replayed, timestamp)
                             VALUES (?, ?, ?, ?, ?, ?)
                         """,
@@ -73,7 +73,7 @@ class TaskOutputSQLiteStorage:
                     fields.append(f"{k} = ?")
                     values.append(json.dumps(v) if isinstance(v, dict) else v)
 
-                query = f"UPDATE latest_kickoff_task_outputs SET {', '.join(fields)} WHERE task_index = ?"
+                query = f"UPDATE latest_kickoff_task_output SET {', '.join(fields)} WHERE task_index = ?"
                 values.append(task_index)
                 cursor.execute(query, tuple(values))
                 conn.commit()
@@ -93,7 +93,7 @@ class TaskOutputSQLiteStorage:
                 cursor = conn.cursor()
                 cursor.execute("""
                 SELECT *
-                FROM task_outputs
+                FROM task_output
                 ORDER BY task_index
                 """)
 
@@ -120,7 +120,7 @@ class TaskOutputSQLiteStorage:
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
-                cursor.execute("DELETE FROM task_outputs")
+                cursor.execute("DELETE FROM task_output")
                 conn.commit()
 
         except sqlite3.Error as e:

versionhq/task/TEMPLATES/Description.py

@@ -1,5 +1,5 @@
-EVALUATE="""Assess the accuracy and quality of the following task output to the task described below. Score based on the criterion (0-1, 0=worst, 1=best) and suggest improvements. Vary scores; don't assign identical values. Store criteria in the "criteria" field.
-Task: {task_description}
-Task Output: {task_output}
+EVALUATE="""Evaluate the provided task output against the given task description, assigning a score between 0 (worst) and 1 (best) based on the specified criteria. Scores should be numerical (integers or decimals). Provide specific suggestions for improvement. Do not assign identical scores to different criteria:
+Task output: {task_output}
+Task description: {task_description}
 Evaluation criteria: {eval_criteria}
 """

versionhq/task/__init__.py

@@ -1,9 +0,0 @@
-from enum import Enum
-
-
-class TaskOutputFormat(str, Enum):
-    """Enum that represents the output format of a task."""
-
-    JSON = "json"
-    PYDANTIC = "pydantic model"
-    RAW = "raw"

versionhq/task/evaluate.py

@@ -1,15 +1,15 @@
 from typing import List, Optional, Dict, Any
 from typing_extensions import Self
 
-from pydantic import BaseModel, Field, InstanceOf, model_validator
+from pydantic import BaseModel, Field, model_validator
+
+from versionhq.memory.model import MemoryMetadata
 
 """
 Evaluate task output from accuracy, token consumption, latency perspectives, and mark the score from 0 to 1.
 """
 
 
-
-
 class ScoreFormat:
     def __init__(self, rate: float | int = 0, weight: int = 1):
         self.rate = rate
@@ -61,10 +61,10 @@ class EvaluationItem(BaseModel):
     """
     criteria: str
     suggestion: str
-    score: int | float
+    score: float
 
     def _convert_score_to_score_format(self, weight: int = 1) -> ScoreFormat | None:
-        if self.score and isinstance(self.score, (int, float)):
+        if self.score and isinstance(self.score, float):
             return ScoreFormat(rate=self.score, weight=weight)
 
         else: return None
@@ -72,7 +72,6 @@ class EvaluationItem(BaseModel):
 
 
 class Evaluation(BaseModel):
-    # expected_outcome: Optional[str] = Field(default=None, description="human input on expected outcome")
     items: List[EvaluationItem] = []
     latency: int = Field(default=None, description="seconds")
     tokens: int = Field(default=None, description="tokens consumed")
@@ -80,11 +79,23 @@ class Evaluation(BaseModel):
 
     @model_validator(mode="after")
     def set_up_responsible_agent(self) -> Self:
-        from versionhq.agent.default_agents import task_evaluator
-        self.responsible_agent = task_evaluator
+        from versionhq.agent.inhouse_agents import vhq_task_evaluator
+        self.responsible_agent = vhq_task_evaluator
         return self
 
 
+    def _create_memory_metadata(self) -> MemoryMetadata:
+        """
+        Create and store evaluation results in the memory metadata
+        """
+        eval_by = self.responsible_agent.role if self.responsible_agent else None
+        score = self.aggregate_score
+        eval_criteria = ", ".join([item.criteria for item in self.items]) if self.items else None
+        suggestion = self.suggestion_summary
+        memory_metadata = MemoryMetadata(eval_by=eval_by, score=score, eval_criteria=eval_criteria, suggestion=suggestion)
+        return memory_metadata
+
+
     @property
     def aggregate_score(self) -> float:
         """

versionhq/task/formation.py

@@ -0,0 +1,123 @@
+from typing import List
+from enum import Enum
+
+from pydantic import BaseModel
+
+from versionhq.task.model import Task
+from versionhq.agent.model import Agent
+from versionhq.team.model import Team, TeamMember, Formation
+from versionhq.agent.inhouse_agents  import vhq_formation_planner
+from versionhq._utils import Logger
+
+
+def form_agent_network(
+        task_overview: str,
+        expected_outcome: str,
+        agents: List[Agent] = None,
+        context: str = None,
+        formation: Formation = None
+    ) -> Team | None:
+    """
+    Make a formation of agents from the given task description, agents (optional), context (optional), and expected outcome (optional).
+    """
+
+    if not task_overview:
+        Logger(verbose=True).log(level="error", message="Missing task description.", color="red")
+        return None
+
+    if not expected_outcome:
+        Logger(verbose=True).log(level="error", message="Missing expected outcome.", color="red")
+        return None
+
+
+    try:
+        class Outcome(BaseModel):
+            formation: Enum
+            agent_roles: list[str]
+            task_descriptions: list[str]
+            leader_agent: str
+
+        vhq_task = Task(
+            description=f"""
+    Create a team of specialized agents designed to automate the following task and deliver the expected outcome. Consider the necessary roles for each agent with a clear task description. If you think we neeed a leader to handle the automation, return a leader_agent role as well, but if not, leave the a leader_agent role blank.
+    Task: {str(task_overview)}
+    Expected outcome: {str(expected_outcome)}
+            """,
+            pydantic_output=Outcome
+        )
+
+        if formation:
+            vhq_task.description += f"Select 1 formation you think the best from the given Enum sets: {str(Formation.__dict__)}"
+
+        if agents:
+            vhq_task.description += "Consider adding following agents in the formation: " + ", ".join([agent.role for agent in agents if isinstance(agent, Agent)])
+
+        res = vhq_task.execute_sync(agent=vhq_formation_planner, context=context)
+        formation_ = Formation.SUPERVISING
+
+        if res.pydantic:
+            formation_keys = [k for k, v in Formation._member_map_.items() if k == res.pydantic.formation.upper()]
+
+            if formation_keys:
+                formation_ = Formation[formation_keys[0]]
+
+            created_agents = [Agent(role=item, goal=item) for item in res.pydantic.agent_roles]
+            created_tasks = [Task(description=item) for item in res.pydantic.task_descriptions]
+            team_tasks = []
+            members = []
+            leader = str(res.pydantic.leader_agent)
+
+            for i in range(len(created_agents)):
+                is_manager = bool(created_agents[i].role.lower() in leader.lower())
+                member = TeamMember(agent=created_agents[i], is_manager=is_manager)
+
+                if len(created_tasks) >= i:
+                    member.task = created_tasks[i]
+                    members.append(member)
+
+            if len(created_agents) < len(created_tasks):
+                team_tasks.extend(created_tasks[len(created_agents) - 1:len(created_tasks)])
+
+            members.sort(key=lambda x: x.is_manager == False)
+            team = Team(members=members, formation=formation_)
+            return team
+
+        else:
+            formation_keys = [k for k, v in Formation._member_map_.items() if k == res.json_dict["formation"].upper()]
+
+            if formation_keys:
+                formation_ = Formation[formation_keys[0]]
+
+            created_agents = [Agent(role=item, goal=item) for item in res.json_dict["agent_roles"]]
+            created_tasks = [Task(description=item) for item in res.json_dict["task_descriptions"]]
+            team_tasks = []
+            members = []
+            leader = str(res.json_dict["leader_agent"])
+
+            for i in range(len(created_agents)):
+                is_manager = bool(created_agents[i].role.lower() in leader.lower())
+                member = TeamMember(agent=created_agents[i], is_manager=is_manager)
+
+                if len(created_tasks) >= i:
+                    member.task = created_tasks[i]
+                    members.append(member)
+
+            if len(created_agents) < len(created_tasks):
+                team_tasks.extend(created_tasks[len(created_agents) - 1:len(created_tasks)])
+
+            members.sort(key=lambda x: x.is_manager == True)
+            team = Team(members=members, formation=formation_)
+            return team
+
+    except Exception as e:
+        Logger(verbose=True).log(level="error", message=f"Failed to create an agent network - return None. You can try with solo agent. Error: {str(e)}", color="red")
+        return None
+
+
+
+if __name__ == "__main__":
+    res = form_agent_network(
+        task_overview="Launch an outbound campaign to attract young audience.",
+        expected_outcome="Best media mix of the campaign.",
+        context="We are selling sports wear.",
+    )