versionhq 1.1.10.7__py3-none-any.whl → 1.1.10.9__py3-none-any.whl

versionhq/task/model.py

@@ -2,6 +2,7 @@ import json
 import threading
 import datetime
 import uuid
+import inspect
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type, TypeVar
@@ -13,6 +14,7 @@ from pydantic_core import PydanticCustomError
 from versionhq._utils.process_config import process_config
 from versionhq.task import TaskOutputFormat
 from versionhq.task.log_handler import TaskOutputStorageHandler
+from versionhq.task.evaluate import Evaluation, EvaluationItem
 from versionhq.tool.model import Tool, ToolSet
 from versionhq._utils.logger import Logger
 
@@ -170,9 +172,7 @@ class TaskOutput(BaseModel):
     pydantic: Optional[Any] = Field(default=None)
     tool_output: Optional[Any] = Field(default=None, description="store tool result when the task takes tool output as its final output")
     callback_output: Optional[Any] = Field(default=None, description="store task or agent callback outcome")
-
-    def __str__(self) -> str:
-        return str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw
+    evaluation: Optional[InstanceOf[Evaluation]] = Field(default=None, description="store overall evaluation of the task output. passed to ltm")
 
 
     def to_dict(self) -> Dict[str, Any] | None:
@@ -189,6 +189,39 @@ class TaskOutput(BaseModel):
         return json.dumps(self.json_dict) if self.json_dict else self.raw[0: 127]
 
 
+    def evaluate(self, task, latency: int | float = None, tokens: int = None) -> Evaluation:
+        """
+        Evaluate the output based on the criteria, score each from 0 to 1 scale, and raise suggestions for future improvement.
+        """
+        from versionhq.task.TEMPLATES.Description import EVALUATE
+
+        if not self.evaluation:
+            self.evaluation = Evaluation()
+
+        self.evaluation.latency = latency if latency is not None else task.latency
+        self.evaluation.tokens = tokens if tokens is not None else task.tokens
+
+        eval_criteria = task.eval_criteria if task.eval_criteria else  ["Overall competitiveness", ]
+
+        for item in eval_criteria:
+            task_1 = Task(
+                description=EVALUATE.format(task_description=task.description, task_output=self.raw, eval_criteria=str(item)),
+                pydantic_output=EvaluationItem
+            )
+            res_a = task_1.execute_sync(agent=self.evaluation.responsible_agent)
+            self.evaluation.items.append(EvaluationItem(**res_a.json_dict))
+
+        return self.evaluation
+
+
+    @property
+    def aggregate_score(self) -> float | int:
+        if self.evaluation is None:
+            return 0
+        else:
+            self.evaluation.aggregate_score
+
+
     @property
     def json(self) -> Optional[str]:
         if self.output_format != TaskOutputFormat.JSON:
@@ -202,6 +235,10 @@ class TaskOutput(BaseModel):
         return json.dumps(self.json_dict)
 
 
+    def __str__(self) -> str:
+        return str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw
+
+
 
 class Task(BaseModel):
     """
@@ -222,14 +259,8 @@ class Task(BaseModel):
     description: str = Field(description="Description of the actual task")
 
     # output
-    pydantic_custom_output: Optional[Any] = Field(
-        default=None,
-        description="store a custom Pydantic class that will be passed to the model as a response format."
-    )
-    response_fields: List[ResponseField] = Field(
-        default_factory=list,
-        description="store the list of ResponseFields to create the response format"
-    )
+    pydantic_output: Optional[Any] = Field(default=None, description="store a custom Pydantic class as response format")
+    response_fields: List[ResponseField] = Field(default_factory=list, description="store the list of ResponseFields to create the response format")
     output: Optional[TaskOutput] = Field(default=None, description="store the final task output in TaskOutput class")
 
     # task setup
@@ -247,11 +278,16 @@ class Task(BaseModel):
     callback: Optional[Callable] = Field(default=None, description="callback to be executed after the task is completed.")
     callback_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict, description="kwargs for the callback when the callback is callable")
 
+    # evaluation
+    should_evaluate: bool = Field(default=False, description="True to run the evaluation flow")
+    eval_criteria: Optional[List[str]] = Field(default_factory=list, description="criteria to evaluate the outcome. i.e., fit to the brand tone")
+
     # recording
     processed_by_agents: Set[str] = Field(default_factory=set, description="store responsible agents' roles")
     tools_errors: int = 0
     delegations: int = 0
-    execution_span_in_sec: int = 0
+    latency: int | float = 0 # execution latency in sec
+    tokens: int = 0 # tokens consumed
 
 
     @model_validator(mode="before")
@@ -276,18 +312,6 @@ class Task(BaseModel):
         return self
 
 
-    # @model_validator(mode="after")
-    # def set_attributes_based_on_config(self) -> Self:
-    #     """
-    #     Set attributes based on the task configuration.
-    #     """
-
-    #     if self.config:
-    #         for key, value in self.config.items():
-    #             setattr(self, key, value)
-    #     return self
-
-
     @model_validator(mode="after")
     def set_up_tools(self) -> Self:
         if not self.tools:
@@ -319,10 +343,10 @@ class Task(BaseModel):
 
         output_prompt = ""
 
-        if self.pydantic_custom_output:
+        if self.pydantic_output:
             output_prompt = f"""
 Your response MUST STRICTLY follow the given repsonse format:
-JSON schema: {str(self.pydantic_custom_output)}
+JSON schema: {str(self.pydantic_output)}
 """
 
         elif self.response_fields:
@@ -339,7 +363,7 @@ Ref. Output image: {output_formats_to_follow}
 """
 
         else:
-            output_prompt = "Return your response as a valid JSON string, enclosed in double quotes. Do not use single quotes, trailing commas, or other non-standard JSON syntax."
+            output_prompt = "Return your response as a valid JSON serializable string, enclosed in double quotes. Do not use single quotes, trailing commas, or other non-standard JSON syntax."
 
         return output_prompt
 
@@ -380,7 +404,7 @@ Ref. Output image: {output_formats_to_follow}
 
     def _structure_response_format(self, data_type: str = "object", model_provider: str = "gemini") -> Dict[str, Any] | None:
         """
-        Structure a response format either from`response_fields` or `pydantic_custom_output`.
+        Structure a response format either from`response_fields` or `pydantic_output`.
         1 nested item is accepted.
         """
 
@@ -412,8 +436,8 @@ Ref. Output image: {output_formats_to_follow}
             }
 
 
-        elif self.pydantic_custom_output:
-            response_format = StructuredOutput(response_format=self.pydantic_custom_output)._format()
+        elif self.pydantic_output:
+            response_format = StructuredOutput(response_format=self.pydantic_output)._format()
 
         return response_format
 
@@ -424,7 +448,7 @@ Ref. Output image: {output_formats_to_follow}
         """
 
         if raw is None or raw == "":
-            self._logger.log(level="error", message="The model returned an empty response. Returning an empty dict.", color="yellow")
+            self._logger.log(level="warning", message="The model returned an empty response. Returning an empty dict.", color="yellow")
             output = { "output": "n.a." }
             return output
 
@@ -453,13 +477,12 @@ Ref. Output image: {output_formats_to_follow}
             return output
 
 
-
     def _create_pydantic_output(self, raw: str = None, json_dict: Dict[str, Any] = None) -> InstanceOf[BaseModel]:
         """
         Create pydantic output from raw or json_dict output.
         """
 
-        output_pydantic = self.pydantic_custom_output
+        output_pydantic = self.pydantic_output
 
         try:
             json_dict = json_dict if json_dict else self._create_json_output(raw=raw)
@@ -481,6 +504,64 @@ Ref. Output image: {output_formats_to_follow}
             self.description = self._original_description.format(**inputs)
 
 
+    def _create_short_term_memory(self, agent, task_output: TaskOutput) -> None:
+        """
+        After the task execution, create and save short-term memory of the responsible agent.
+        """
+
+        from versionhq.agent.model import Agent
+        from versionhq.memory.model import ShortTermMemory
+
+        try:
+            if isinstance(agent, Agent) and agent.use_memory == True:
+                if hasattr(agent, "short_term_memory"):
+                    agent.short_term_memory.save(value=task_output.raw, metadata={ "observation": self.description, }, agent=agent.role)
+                else:
+                    agent.short_term_memory = ShortTermMemory(agent=agent, embedder_config=agent.embedder_config)
+                    agent.short_term_memory.save(value=task_output.raw, metadata={ "observation": self.description, }, agent=agent.role)
+
+        except Exception as e:
+            self._logger.log(level="error", message=f"Failed to add to short term memory: {str(e)}", color="red")
+            pass
+
+
+    def _create_long_term_memory(self, agent, task_output: TaskOutput) -> None:
+        """
+        Create and save long-term and entity memory items based on evaluation.
+        """
+        from versionhq.agent.model import Agent
+        from versionhq.memory.model import LongTermMemory, LongTermMemoryItem
+
+        try:
+            if isinstance(agent, Agent) and agent.use_memory == True:
+                evaluation = task_output.evaluation if task_output.evaluation else task_output.evaluate(task=self)
+
+                long_term_memory_item = LongTermMemoryItem(
+                    agent=str(agent.role),
+                    task=str(self.description),
+                    datetime=str(datetime.datetime.now()),
+                    quality=evaluation.aggregate_score,
+                    metadata={
+                        "suggestions": evaluation.suggestion_summary,
+                        "quality": evaluation.aggregate_score,
+                    },
+                )
+
+                if hasattr(agent, "long_term_memory"):
+                    agent.long_term_memory.save(item=long_term_memory_item)
+                else:
+                    agent.long_term_memory = LongTermMemory(agent=agent)
+                    agent.long_term_memory.save(item=long_term_memory_item)
+
+        except AttributeError as e:
+            self._logger.log(level="error", message=f"Missing attributes for long term memory: {str(e)}", color="red")
+            pass
+
+        except Exception as e:
+            self._logger.log(level="error", message=f"Failed to add to long term memory: {str(e)}", color="red")
+            pass
+
+
     # task execution
     def execute_sync(self, agent, context: Optional[str] = None) -> TaskOutput:
         """
@@ -527,7 +608,7 @@ Ref. Output image: {output_formats_to_follow}
         self.prompt_context = context
         task_output: InstanceOf[TaskOutput] = None
         tool_output: str | list = None
-        task_tools: List[InstanceOf[Tool] | InstanceOf[ToolSet] | Type[Tool]] = []
+        task_tools: List[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = []
         started_at = datetime.datetime.now()
 
         if self.tools:
@@ -563,20 +644,34 @@ Ref. Output image: {output_formats_to_follow}
             if "outcome" in json_dict_output:
                 json_dict_output = self._create_json_output(raw=str(json_dict_output["outcome"]))
 
-            pydantic_output = self._create_pydantic_output(raw=raw_output, json_dict=json_dict_output) if self.pydantic_custom_output else None
+            pydantic_output = self._create_pydantic_output(raw=raw_output, json_dict=json_dict_output) if self.pydantic_output else None
 
             task_output = TaskOutput(
                 task_id=self.id,
-                raw=raw_output,
+                raw=raw_output if raw_output is not None else "",
                 pydantic=pydantic_output,
                 json_dict=json_dict_output
             )
 
+        ended_at = datetime.datetime.now()
+        self.latency = (ended_at - started_at).total_seconds()
+
         self.output = task_output
         self.processed_by_agents.add(agent.role)
 
+        if self.should_evaluate:
+            task_output.evaluate(task=self, latency=self.latency, tokens=self.tokens)
+
+        self._create_short_term_memory(agent=agent, task_output=task_output)
+        self._create_long_term_memory(agent=agent, task_output=task_output)
+
+
         if self.callback and isinstance(self.callback, Callable):
-            callback_res = self.callback(**self.callback_kwargs, **task_output.json_dict)
+            kwargs = { **self.callback_kwargs, **task_output.json_dict }
+            sig = inspect.signature(self.callback)
+            valid_keys = [param.name for param in sig.parameters.values() if param.kind == param.POSITIONAL_OR_KEYWORD]
+            valid_kwargs = { k: kwargs[k] for k in valid_keys }
+            callback_res = self.callback(**valid_kwargs)
             task_output.callback_output = callback_res
 
         # if self.output_file: ## disabled for now
@@ -586,10 +681,6 @@ Ref. Output image: {output_formats_to_follow}
         #         else pydantic_output.model_dump_json() if pydantic_output else result
         #     )
         #     self._save_file(content)
-
-        ended_at = datetime.datetime.now()
-        self.execution_span_in_sec = (ended_at - started_at).total_seconds()
-
         return task_output
 
 
@@ -603,7 +694,7 @@ Ref. Output image: {output_formats_to_follow}
 
     @property
     def key(self) -> str:
-        output_format = TaskOutputFormat.JSON if self.response_fields else TaskOutputFormat.PYDANTIC if self.pydantic_custom_output is not None else TaskOutputFormat.RAW
+        output_format = TaskOutputFormat.JSON if self.response_fields else TaskOutputFormat.PYDANTIC if self.pydantic_output is not None else TaskOutputFormat.RAW
         source = [self.description, output_format]
         return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
 
@@ -656,7 +747,7 @@ class ConditionalTask(Task):
         previous_output = task_outputs[task_index - 1] if task_outputs and len(task_outputs) > 1  else None
 
         if previous_output and not self.should_execute(previous_output):
-            self._logger.log(level="debug", message=f"Skipping conditional task: {self.description}", color="yellow")
+            self._logger.log(level="warning", message=f"Skipping conditional task: {self.description}", color="yellow")
             skipped_task_output = self.get_skipped_task_output()
             self.output = skipped_task_output
 

versionhq/team/team_planner.py

@@ -86,7 +86,7 @@ class TeamPlanner:
 
                 Task summaries: {" ".join(task_summary_list)}
             """,
-            pydantic_custom_output=TeamPlanIdea
+            pydantic_output=TeamPlanIdea
         )
         output = task.execute_sync(agent=team_planner, context=context, tools=tools)
         return output

versionhq/tool/model.py

@@ -58,7 +58,7 @@ class BaseTool(ABC, BaseModel):
             "type": cls.object_type,
             "function": {
                 "name": cls.name.replace(" ", "_"),
-                "description": cls.description,
+                "description": cls.description if cls.description else "",
                 "parameters": {
                     "type": "object",
                     "properties": p,
@@ -174,7 +174,7 @@ class Tool(BaseTool):
     @model_validator(mode="after")
     def set_up_name(self) -> Self:
         if not self.name:
-            self.name = self.func.__name__ if self.func else ""
+            self.name = self.func.__name__ if self.func.__name__ != "<lambda>" else "random_func"
 
         return self
 
@@ -187,7 +187,7 @@ class Tool(BaseTool):
 
             args_schema = {
                 name: {
-                    "description": field.description,
+                    "description": field.description if field.description else "",
                     "type": self._get_arg_annotations(field.annotation),
                 }
                 for name, field in self.args_schema.model_fields.items()
@@ -214,34 +214,36 @@ class Tool(BaseTool):
         """
 
         p, r = dict(), list()
-        if self.args_schema:
-            for name, field in self.args_schema.model_fields.items():
-                if name != "kwargs" and name != "args":
-                    p.update(
-                        {
-                            name: {
-                                "description": field.description if field.description else "",
-                                "type": SchemaType(self._get_arg_annotations(field.annotation)).convert(),
-                            }
+        if not self.args_schema:
+            self.args_schema = self.set_up_args_schema()
+
+        for name, field in self.args_schema.model_fields.items():
+            if name != "kwargs" and name != "args":
+                p.update(
+                    {
+                        name: {
+                            "description": field.description if field.description else "",
+                            "type": SchemaType(self._get_arg_annotations(field.annotation)).convert(),
                         }
-                    )
-                    r.append(name)
-
-            properties = {
-                "type": self.object_type,
-                "function": {
-                    "name": self.name.replace(" ", "_"),
-                    "description": self.description if self.description else "a tool function to execute",
-                    "parameters": {
-                        "type": "object",
-                        "properties": p,
-                        "required": r,
-                        "additionalProperties": False
-                    },
-                    "strict": True,
+                    }
+                )
+                r.append(name)
+
+        properties = {
+            "type": self.object_type,
+            "function": {
+                "name": self.name.replace(" ", "_"),
+                "description": self.description if self.description else "a tool function to execute",
+                "parameters": {
+                    "type": "object",
+                    "properties": p,
+                    "required": r,
+                    "additionalProperties": False
                 },
-            }
-            self.properties = properties
+                "strict": True,
+            },
+        }
+        self.properties = properties
         return self
 
 
@@ -294,7 +296,7 @@ class Tool(BaseTool):
 
     def _handle_toolset(self, params: Dict[str, Any] = None) -> Any:
         """
-        Read the cache from the ToolHandler instance or execute _run() method.
+        Return cached results or run the function and record the results.
         """
 
         from versionhq.tool.tool_handler import ToolHandler
@@ -308,28 +310,24 @@ class Tool(BaseTool):
         parsed_kwargs = self._parse_args(raw_args=acceptable_kwargs)
         tool_set = ToolSet(tool=self, kwargs=acceptable_kwargs)
 
-        if self.tool_handler and isinstance(self.tool_handler, ToolHandler):
-            if self.tool_handler.has_called_before(tool_set):
-                self.tool_handler.error = "Agent execution error"
+        if not self.tool_handler or not isinstance(self.tool_handler, ToolHandler):
+            self.tool_handler = ToolHandler(last_used_tool=tool_set, cache_handler=self.cache_handler, should_cache=self.should_cache)
 
-            elif self.tool_handler.cache:
+        try:
+            if self.tool_handler.has_called_before(tool_set) or self.tool_handler.cache:
                 result = self.tool_handler.cache.read(tool_name=tool_set.tool.name, input=str(tool_set.kwargs))
-                if not result:
-                    result = self.func(**parsed_kwargs)
 
-            else:
+            if not result:
                 result = self.func(**parsed_kwargs)
 
-        else:
-            tool_handler = ToolHandler(last_used_tool=tool_set, cache_handler=self.cache_handler, should_cache=self.should_cache)
-            self.tool_handler = tool_handler
-            result = self.func(**parsed_kwargs)
-
+            if self.should_cache is True:
+                self.tool_handler.record_last_tool_used(last_used_tool=tool_set, output=result, should_cache=self.should_cache)
 
-        if self.should_cache is True:
-            self.tool_handler.record_last_tool_used(last_used_tool=tool_set, output=result, should_cache=self.should_cache)
+            return result
 
-        return result
+        except:
+            self.tool_handler.error = "Agent error"
+            return result
 
 
     def run(self, params: Dict[str, Any] = None) -> Any:
@@ -344,5 +342,5 @@ class ToolSet(BaseModel):
     """
     Store the tool called and any kwargs used. (The tool name and kwargs will be stored in the cache.)
     """
-    tool: InstanceOf[Tool] | Type[Tool] = Field(..., description="store the tool instance to be called.")
+    tool: InstanceOf[Tool]| Type[Tool] = Field(..., description="store the tool instance to be called.")
     kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")

{versionhq-1.1.10.7.dist-info → versionhq-1.1.10.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.10.7
+Version: 1.1.10.9
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -56,24 +56,29 @@ Requires-Dist: appdirs>=1.4.4
 Requires-Dist: langchain>=0.3.14
 Requires-Dist: langchain-openai>=0.2.14
 Requires-Dist: composio-langchain>=0.6.12
+Requires-Dist: chromadb>=0.6.3
+Requires-Dist: docling>=2.16.0
+Requires-Dist: json-repair>=0.35.0
+Requires-Dist: wheel>=0.45.1
+Requires-Dist: pdfplumber>=0.11.5
+Requires-Dist: mem0ai>=0.1.48
 
 # Overview
 
 ![MIT license](https://img.shields.io/badge/License-MIT-green)
 [![Publisher](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml/badge.svg)](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml)
 ![PyPI](https://img.shields.io/badge/PyPI->=v1.1.10-blue)
-![python ver](https://img.shields.io/badge/Python-3.12/3.13-purple)
+![python ver](https://img.shields.io/badge/Python->=3.12-purple)
 ![pyenv ver](https://img.shields.io/badge/pyenv-2.5.0-orange)
 
 
-LLM orchestration frameworks to deploy multi-agent systems focusing on complex outbound tasks.
+LLM orchestration frameworks to deploy multi-agent systems with task-based formation.
 
 **Visit:**
 
 - [PyPI](https://pypi.org/project/versionhq/)
 - [Github (LLM orchestration framework)](https://github.com/versionHQ/multi-agent-system)
-- [Github (Test client app)](https://github.com/versionHQ/test-client-app)
-- [Use case](https://versi0n.io/playground) / [Quick demo](https://res.cloudinary.com/dfeirxlea/video/upload/v1737732977/pj_m_home/pnsyh5mfvmilwgt0eusa.mov)
+- [Use case](https://versi0n.io/) / [Quick demo](https://res.cloudinary.com/dfeirxlea/video/upload/v1737732977/pj_m_home/pnsyh5mfvmilwgt0eusa.mov)
 - [Documentation](https://chief-oxygen-8a2.notion.site/Documentation-17e923685cf98001a5fad5c4b2acd79b?pvs=4) *Some components are under review.
 
 
@@ -86,9 +91,9 @@ LLM orchestration frameworks to deploy multi-agent systems focusing on complex o
 - [Key Features](#key-features)
   - [Agent formation](#agent-formation)
 - [Quick Start](#quick-start)
-  - [Case 1. Single agent network:](#case-1-single-agent-network)
+  - [Case 1. Solo Agent:](#case-1-solo-agent)
     - [Return a structured output with a summary in string.](#return-a-structured-output-with-a-summary-in-string)
-  - [Case 2. Form a team to handle multiple tasks:](#case-2-form-a-team-to-handle-multiple-tasks)
+  - [Case 2. Supervising:](#case-2-supervising)
 - [Technologies Used](#technologies-used)
 - [Project Structure](#project-structure)
 - [Setup](#setup)
@@ -133,10 +138,10 @@ You can specify which formation you want them to generate, or let the agent deci
    pip install versionhq
    ```
 
-(Python >= 3.13)
+(Python >= 3.12)
 
 
-### Case 1. Single agent network:
+### Case 1. Solo Agent:
 
 #### Return a structured output with a summary in string.
 
@@ -177,7 +182,7 @@ This will return `TaskOutput` that stores a response in string, JSON dict, and P
    )
    ```
 
-### Case 2. Form a team to handle multiple tasks:
+### Case 2. Supervising:
 
    ```
    from versionhq.agent.model import Agent
@@ -212,19 +217,21 @@ This will return a list with dictionaries with keys defined in the `ResponseFiel
 
 Tasks can be delegated to a team manager, peers in the team, or completely new agent.
 
-
 <hr />
 
 ## Technologies Used
-**Schema, Database, Data Validation**
-   - [Pydantic](https://docs.pydantic.dev/latest/): Data validation and serialization library for Python
-   - [Pydantic_core](https://pypi.org/project/pydantic-core/): Core func packages for Pydantic
-   - [Chroma DB](https://docs.trychroma.com/): Vector database for storing and querying usage data
-   - [SQLite](https://www.sqlite.org/docs.html): C-language library to implements a small SQL database engine
+**Schema, Data Validation**
+   - [Pydantic](https://docs.pydantic.dev/latest/): Data validation and serialization library for Python.
+   - [Pydantic_core](https://pypi.org/project/pydantic-core/): Core func packages for Pydantic.
    - [Upstage](https://console.upstage.ai/docs/getting-started/overview): Document processer for ML tasks. (Use `Document Parser API` to extract data from documents)
+   - [Docling](https://ds4sd.github.io/docling/): Document parsing
+
+**Storage**
+   - [mem0ai](https://docs.mem0.ai/quickstart#install-package): Agents' memory storage and management.
+   - [Chroma DB](https://docs.trychroma.com/): Vector database for storing and querying usage data.
+   - [SQLite](https://www.sqlite.org/docs.html): C-language library to implements a small SQL database engine.
 
 **LLM-curation**
-   - OpenAI GPT-4: Advanced language model for analysis and recommendations
    - [LiteLLM](https://docs.litellm.ai/docs/providers): Curation platform to access LLMs
 
 **Tools**
@@ -242,27 +249,29 @@ Tasks can be delegated to a team manager, peers in the team, or completely new a
 
 ```
 .
+.github
+└── workflows/                # Github actions
+│
 src/
-└── versionHQ/                  # Orchestration frameworks on Pydantic
-│      ├── agent/
-│      └── llm/
-│      └── task/
-│      └── team/
-│      └── tool/
-│      └── clients/            # Classes to store the client related information
-│      └── cli/                # CLI commands
-│      └── ...
-│      │
-│      ├── db/                 # Database files
-│      ├── chroma.sqlite3
-│      └── ...
+└── versionhq/                # Orchestration frameworks
+│     ├── agent/              # Components
+│     └── llm/
+│     └── task/
+│     └── team/
+│     └── tool/
+│     └── cli/
+│     └── ...
+│     │
+│     ├── db/                 # Storage
+│     ├── chroma.sqlite3
+│     └── ...
+│
+└──tests/                     # Pytest
+│     └── agent/
+│     └── llm/
+│     └── ...
 │
-└──tests/
-      └── cli/
-      └── team/
-      └── ...
-      │
-      └── uploads/    # Uploaded files for the project
+└── uploads/                  # Local repo to store the uploaded files
 
 ```
 
@@ -284,9 +293,9 @@ src/
 
 * In case of AssertionError/module mismatch, run Python version control using `.pyenv`
    ```
-   pyenv install 3.13.1
-   pyenv global 3.13.1  (optional: `pyenv global system` to get back to the system default ver.)
-   uv python pin 3.13.1
+   pyenv install 3.12.8
+   pyenv global 3.12.8  (optional: `pyenv global system` to get back to the system default ver.)
+   uv python pin 3.12.8
    ```
 
 3. Set up environment variables: