versionhq 1.1.6.3__py3-none-any.whl → 1.1.7.0__py3-none-any.whl

versionhq/team/model.py

@@ -56,39 +56,29 @@ class TaskHandlingProcess(str, Enum):
     """
     Class representing the different processes that can be used to tackle multiple tasks.
     """
-
     sequential = "sequential"
     hierarchical = "hierarchical"
     consensual = "consensual"
 
 
 class TeamOutput(BaseModel):
-    """Class that represents the result of a team."""
+    """
+    Store outputs of the tasks handled by the team.
+    `json_dict` and `raw` store overall output of tasks that handled by the team,
+    while `task_output_list` stores each TaskOutput instance to the tasks handled by the team members.
+    Note that `raw` and `json_dict` will be prioritized as TeamOutput to refer over `task_output_list`.
+    """
 
-    team_id: UUID4 = Field(
-        default_factory=uuid.uuid4,
-        frozen=True,
-        description="store the team ID that generate the TeamOutput",
-    )
-    raw: str = Field(default="", description="raw output")
-    pydantic: Optional[BaseModel] = Field(default=None, description="pydantic output")
-    json_dict: Optional[Dict[str, Any]] = Field(
-        default=None, description="JSON dict output"
-    )
-    task_output_list: list[TaskOutput] = Field(
-        default=list,
-        description="store output of all the tasks that the team has executed",
-    )
-    token_usage: UsageMetrics = Field(
-        default=dict, description="processed token summary"
-    )
+    team_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store the team ID that generate the TeamOutput")
+    raw: str = Field(default="", description="raw output of the team lead task handled by the team leader")
+    pydantic: Optional[Any] = Field(default=None, description="`raw` converted to the abs. pydantic model")
+    json_dict: Union[Dict[str, Any]] = Field(default=None, description="`raw` converted to dictionary")
+    task_output_list: list[TaskOutput] = Field(default=list, description="store output of all the tasks that the team has executed")
+    token_usage: UsageMetrics = Field(default=dict, description="processed token summary")
 
     def __str__(self):
-        return (
-            str(self.pydantic)
-            if self.pydantic
-            else str(self.json_dict) if self.json_dict else self.raw
-        )
+        return (str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw)
+
 
     def __getitem__(self, key):
         if self.pydantic and hasattr(self.pydantic, key):
@@ -98,6 +88,7 @@ class TeamOutput(BaseModel):
         else:
             raise KeyError(f"Key '{key}' not found in the team output.")
 
+
     @property
     def json(self) -> Optional[str]:
         if self.tasks_output[-1].output_format != TaskOutputFormat.JSON:
@@ -106,6 +97,7 @@ class TeamOutput(BaseModel):
             )
         return json.dumps(self.json_dict)
 
+
     def to_dict(self) -> Dict[str, Any]:
         """
         Convert json_output and pydantic_output to a dictionary.
@@ -116,15 +108,11 @@ class TeamOutput(BaseModel):
         elif self.pydantic:
             output_dict.update(self.pydantic.model_dump())
         else:
-            output_dict.update({"raw", self.raw})
+            output_dict.update({"output", self.raw})
         return output_dict
 
     def return_all_task_outputs(self) -> List[Dict[str, Any]]:
-        res = []
-        for output in self.task_output_list:
-            if output is not None:
-                res.append(output.to_dict())
-
+        res = [output.json_dict for output in self.task_output_list]
         return res
 
 
@@ -149,71 +137,42 @@ class Team(BaseModel):
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None)
-    members: List[TeamMember] = Field(
-        default_factory=list,
-        description="store agents' uuids and bool if it is manager",
-    )
+    members: List[TeamMember] = Field(default_factory=list, description="store agents' uuids and bool if it is manager")
 
     # work as a team
-    team_tasks: Optional[List[Task]] = Field(
-        default_factory=list, description="optional tasks for the team"
-    )
-    planning_llm: Optional[Any] = Field(
-        default=None,
-        description="llm to handle the planning of the team tasks (if any)",
-    )
-    function_calling_llm: Optional[Any] = Field(
-        default=None,
-        description="llm to execute func after all agent execution (if any)",
-    )
-    prompt_file: str = Field(
-        default="", description="path to the prompt json file to be used by the team."
-    )
+    team_tasks: Optional[List[Task]] = Field(default_factory=list, description="optional tasks for the team")
+    planning_llm: Optional[Any] = Field(default=None, description="llm to handle the planning of the team tasks (if any)")
+    function_calling_llm: Optional[Any] = Field(default=None, description="llm to execute func after all agent execution (if any)")
+    prompt_file: str = Field(default="", description="path to the prompt json file to be used by the team.")
     process: TaskHandlingProcess = Field(default=TaskHandlingProcess.sequential)
 
     # callbacks
-    before_kickoff_callbacks: List[
-        Callable[[Optional[Dict[str, Any]]], Optional[Dict[str, Any]]]
-    ] = Field(
+    before_kickoff_callbacks: List[Callable[[Optional[Dict[str, Any]]], Optional[Dict[str, Any]]]] = Field(
         default_factory=list,
-        description="list of callback functions to be executed before the team kickoff. i.e., adjust inputs",
+        description="list of callback functions to be executed before the team kickoff. i.e., adjust inputs"
     )
     after_kickoff_callbacks: List[Callable[[TeamOutput], TeamOutput]] = Field(
         default_factory=list,
-        description="list of callback functions to be executed after the team kickoff. i.e., store the result in repo",
-    )
-    task_callback: Optional[Any] = Field(
-        default=None,
-        description="callback to be executed after each task for all agents execution",
-    )
-    step_callback: Optional[Any] = Field(
-        default=None,
-        description="callback to be executed after each step for all agents execution",
+        description="list of callback functions to be executed after the team kickoff. i.e., store the result in repo"
     )
+    task_callback: Optional[Any] = Field(default=None, description="callback to be executed after each task for all agents execution")
+    step_callback: Optional[Any] = Field(default=None, description="callback to be executed after each step for all agents execution")
 
     verbose: bool = Field(default=True)
     cache: bool = Field(default=True)
-    memory: bool = Field(
-        default=False,
-        description="whether the team should use memory to store memories of its execution",
-    )
-    execution_logs: List[Dict[str, Any]] = Field(
-        default=[], description="list of execution logs for tasks"
-    )
-    usage_metrics: Optional[UsageMetrics] = Field(
-        default=None, description="usage metrics for all the llm executions"
-    )
+    memory: bool = Field(default=False, description="whether the team should use memory to store memories of its execution")
+    execution_logs: List[Dict[str, Any]] = Field(default=[], description="list of execution logs for tasks")
+    usage_metrics: Optional[UsageMetrics] = Field(default=None, description="usage metrics for all the llm executions")
 
     def __name__(self) -> str:
-        return self.name if self.name is not None else self.id
+        return self.name if self.name is not None else self.id.__str__
 
     @property
     def key(self) -> str:
-        source = [member.agent.key for member in self.members] + [
-            task.key for task in self.tasks
-        ]
+        source = [str(member.agent.id.__str__) for member in self.members] + [str(task.id.__str__) for task in self.tasks]
         return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
 
+
     @property
     def manager_agent(self) -> Agent:
         manager_agent = [
@@ -221,6 +180,7 @@ class Team(BaseModel):
         ]
         return manager_agent[0] if len(manager_agent) > 0 else None
 
+
     @property
     def manager_task(self) -> Task:
         """
@@ -230,6 +190,7 @@ class Team(BaseModel):
         task = [member.task for member in self.members if member.is_manager == True]
         return task[0] if len(task) > 0 else None
 
+
     @property
     def tasks(self):
         """
@@ -253,9 +214,7 @@ class Team(BaseModel):
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         """Prevent manual setting of the 'id' field by users."""
         if v:
-            raise PydanticCustomError(
-                "may_not_set_field", "The 'id' field cannot be set by the user.", {}
-            )
+            raise PydanticCustomError("may_not_set_field", "The 'id' field cannot be set by the user.", {})
 
     # @field_validator("config", mode="before")
     # @classmethod
@@ -286,6 +245,7 @@ class Team(BaseModel):
                 )
         return self
 
+
     @model_validator(mode="after")
     def validate_tasks(self):
         """
@@ -381,13 +341,16 @@ class Team(BaseModel):
             return skipped_task_output
         return None
 
-    def _create_team_output(self, task_outputs: List[TaskOutput]) -> TeamOutput:
-        if len(task_outputs) != 1:
-            raise ValueError(
-                "Something went wrong. Kickoff should return only one task output."
-            )
 
-        final_task_output = task_outputs[0]
+    def _create_team_output(self, task_outputs: List[TaskOutput], lead_task_output: TaskOutput = None) -> TeamOutput:
+        """
+        Take the output of the first task or the lead task output as the team output `raw` value.
+        Note that `tasks` are already sorted by the importance.
+        """
+        if len(task_outputs) < 1:
+            raise ValueError("Something went wrong. Kickoff should return only one task output.")
+
+        final_task_output = lead_task_output if lead_task_output is not None else task_outputs[0]
         # final_string_output = final_task_output.raw
         # self._finish_execution(final_string_output)
         token_usage = self._calculate_usage_metrics()
@@ -395,12 +358,13 @@ class Team(BaseModel):
         return TeamOutput(
             team_id=self.id,
             raw=final_task_output.raw,
-            pydantic=final_task_output.pydantic,
             json_dict=final_task_output.json_dict,
-            task_output_list=[task.output for task in self.tasks if task.output],
+            pydantic=final_task_output.pydantic,
+            task_output_list=task_outputs,
             token_usage=token_usage,
         )
 
+
     def _calculate_usage_metrics(self) -> UsageMetrics:
         """
         Calculate and return the usage metrics that consumed by the team.
@@ -420,12 +384,8 @@ class Team(BaseModel):
         self.usage_metrics = total_usage_metrics
         return total_usage_metrics
 
-    def _execute_tasks(
-        self,
-        tasks: List[Task],
-        start_index: Optional[int] = 0,
-        was_replayed: bool = False,
-    ) -> TeamOutput:
+
+    def _execute_tasks(self, tasks: List[Task], start_index: Optional[int] = 0, was_replayed: bool = False) -> TeamOutput:
         """
         Executes tasks sequentially and returns the final output in TeamOutput class.
         When we have a manager agent, we will start from executing manager agent's tasks.
@@ -434,6 +394,7 @@ class Team(BaseModel):
         """
 
         task_outputs: List[TaskOutput] = []
+        lead_task_output: TaskOutput = None
         futures: List[Tuple[Task, Future[TaskOutput], int]] = []
         last_sync_output: Optional[TaskOutput] = None
 
@@ -449,77 +410,44 @@ class Team(BaseModel):
 
             responsible_agent = self._get_responsible_agent(task)
             if responsible_agent is None:
-                responsible_agent = self.members[
-                    0
-                ].agent  #! REFINEME - select a suitable agent for the task
+                responsible_agent = self.manager_agent if self.manager_agent else self.members[0].agent
 
             # self._prepare_agent_tools(task)
             # self._log_task_start(task, responsible_agent)
 
             if isinstance(task, ConditionalTask):
-                skipped_task_output = self._handle_conditional_task(
-                    task, task_outputs, futures, task_index, was_replayed
-                )
+                skipped_task_output = self._handle_conditional_task(task, task_outputs, futures, task_index, was_replayed)
                 if skipped_task_output:
                     continue
 
             if task.async_execution:
-                context = create_raw_outputs(
-                    tasks=[
-                        task,
-                    ],
-                    task_outputs=(
-                        [
-                            last_sync_output,
-                        ]
-                        if last_sync_output
-                        else []
-                    ),
-                )
-                future = task.execute_async(
-                    agent=responsible_agent,
-                    context=context,
-                    # tools=responsible_agent.tools,
-                )
+                context = create_raw_outputs(tasks=[task, ],task_outputs=([last_sync_output,] if last_sync_output else []))
+                future = task.execute_async(agent=responsible_agent, context=context,
+                                            # tools=responsible_agent.tools
+                                            )
                 futures.append((task, future, task_index))
             else:
                 if futures:
                     task_outputs = self._process_async_tasks(futures, was_replayed)
                     futures.clear()
 
-                context = create_raw_outputs(
-                    tasks=[
-                        task,
-                    ],
-                    task_outputs=(
-                        [
-                            last_sync_output,
-                        ]
-                        if last_sync_output
-                        else []
-                    ),
-                )
-                task_output = task.execute_sync(
-                    agent=responsible_agent,
-                    context=context,
-                    # tools=responsible_agent.tools,
-                )
-                task_outputs = [
-                    task_output,
-                ]
+                context = create_raw_outputs(tasks=[task,], task_outputs=([ last_sync_output,] if last_sync_output else [] ))
+                task_output = task.execute_sync(agent=responsible_agent, context=context,
+                                                # tools=responsible_agent.tools
+                                                )
+                if responsible_agent is self.manager_agent:
+                    lead_task_output = task_output
+
+                task_outputs.append(task_output)
                 # self._process_task_result(task, task_output)
                 # self._store_execution_log(task, task_output, task_index, was_replayed)
 
         # if futures:
         # task_outputs = self._process_async_tasks(futures, was_replayed)
+        return self._create_team_output(task_outputs, lead_task_output)
 
-        return self._create_team_output(task_outputs)
 
-    def kickoff(
-        self,
-        kwargs_before: Optional[Dict[str, str]] = None,
-        kwargs_after: Optional[Dict[str, Any]] = None,
-    ) -> TeamOutput:
+    def kickoff(self, kwargs_before: Optional[Dict[str, str]] = None, kwargs_after: Optional[Dict[str, Any]] = None) -> TeamOutput:
         """
         Kickoff the team:
         0. Plan the team action if we have `team_tasks` using `planning_llm`.
@@ -553,7 +481,6 @@ class Team(BaseModel):
 
         for member in self.members:
             agent = member.agent
-            # agent.i18n = i18n
             agent.team = self
 
             # add the team's common callbacks to each agent.
@@ -574,9 +501,7 @@ class Team(BaseModel):
         for after_callback in self.after_kickoff_callbacks:
             result = after_callback(result, **kwargs_after)
 
-        metrics += [
-            member.agent._token_process.get_summary() for member in self.members
-        ]
+        metrics += [member.agent._token_process.get_summary() for member in self.members]
 
         self.usage_metrics = UsageMetrics()
         for metric in metrics:

versionhq/team/team_planner.py

@@ -36,13 +36,13 @@ class TeamPlanner:
         task_to_handle = Task(
             description=f"""
                 Based on the following task summaries, create the most descriptive plan that the team can execute most efficiently. Take all the task summaries - task's description and tools available - into consideration. Your answer only contains a dictionary.
-                
+
                 Task summaries: {" ".join(task_summary_list)}
              """,
             expected_output_json=False,
             expected_output_pydantic=True,
             output_field_list=[
-                ResponseField(title=f"{task.id}", type="str", required=True)
+                ResponseField(title=f"{task.id}", type=str, required=True)
                 for task in self.tasks
             ],
         )

versionhq/tool/model.py

@@ -35,14 +35,12 @@ class Tool(ABC, BaseModel):
     @property
     def description(self):
         args_schema = {
-            name: {
-                "description": field.description,
-                "type": Tool._get_arg_annotations(field.annotation),
-            }
+            name: { "description": field.description,  "type": Tool._get_arg_annotations(field.annotation) }
             for name, field in self.args_schema.model_fields.items()
         }
         return f"Tool Name: {self.name}\nTool Arguments: {args_schema}\nTool Description: {self.description}"
 
+
     @field_validator("args_schema", mode="before")
     @classmethod
     def _default_args_schema(cls, v: Type[BaseModel]) -> Type[BaseModel]:
@@ -188,21 +186,13 @@ class ToolCalled(BaseModel):
     Store the tool called and any kwargs used.
     """
 
-    tool: InstanceOf[Tool] = Field(
-        ..., description="store the tool instance to be called."
-    )
-    arguments: Optional[Dict[str, Any]] = Field(
-        ..., description="kwargs passed to the tool"
-    )
+    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    arguments: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
 class InstructorToolCalled(BaseModel):
-    tool: InstanceOf[Tool] = Field(
-        ..., description="store the tool instance to be called."
-    )
-    arguments: Optional[Dict[str, Any]] = Field(
-        ..., description="kwargs passed to the tool"
-    )
+    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    arguments: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
 class CacheTool(BaseModel):

{versionhq-1.1.6.3.dist-info → versionhq-1.1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.6.3
+Version: 1.1.7.0
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -52,7 +52,8 @@ Requires-Dist: wheel>=0.45.1
 
 # Overview
 
-![python ver](https://img.shields.io/badge/Python-3.13.1-blue) ![pyenv ver](https://img.shields.io/badge/pyenv-2.4.23-orange)
+![MIT license](https://img.shields.io/badge/License-MIT-green) ![PyPi](https://img.shields.io/badge/pypi-v1.1.6.3-blue)
+![python ver](https://img.shields.io/badge/Python-3.12/3.13-purple) ![pyenv ver](https://img.shields.io/badge/pyenv-2.4.23-orange)
 
 
 An LLM orchestration frameworks for multi-agent systems with RAG to autopilot outbound workflows.
@@ -64,10 +65,10 @@ Messaging workflows are created at individual level, and will be deployed on thi
 
 **Visit:**
 
-- Marketing:   [Landing page](https://home.versi0n.io)
-- Client app:  [Production](https://versi0n.io/)
-- Backend:     [Orchestration + multi-agent RAG system](https://github.com/versionHQ/multi-agent-system)
-- Test CI:     [Test client app (React)](https://github.com/versionHQ/test-client-app)
+- [Landing page](https://home.versi0n.io)
+- [Client app](https://versi0n.io/)
+- [Orchestration frameworks](https://github.com/versionHQ/multi-agent-system)
+- [Test client app](https://github.com/versionHQ/test-client-app)
 
 
 ## Mindmap
@@ -75,7 +76,7 @@ Messaging workflows are created at individual level, and will be deployed on thi
 LLM-powered `agent`s and `team`s use `tool`s and their own knowledge to complete the `task` given by the client or the system.
 
 <p align="center">
-   <img src="https://res.cloudinary.com/dfeirxlea/image/upload/v1733556715/pj_m_home/urwte15at3h0dr8mdlyo.png" alt="mindmap" width="1000">
+   <img src="https://res.cloudinary.com/dfeirxlea/image/upload/v1733556715/pj_m_home/urwte15at3h0dr8mdlyo.png" alt="mindmap" width="400">
 </p>
 
 <hr />
@@ -89,8 +90,7 @@ LLM-powered `agent`s and `team`s use `tool`s and their own knowledge to complete
 - [Project Structure](#project-structure)
 - [Setup](#setup)
 - [Usage](#usage)
-- [Installing as a Package Module (Alpha)](#installing-as-a-package-module-alpha)
-- [Contributing & Customizing](#contributing--customizing)
+- [Contributing](#contributing)
   - [Customizing AI Agents](#customizing-ai-agents)
   - [Modifying RAG Functionality](#modifying-rag-functionality)
   - [Package Management with uv](#package-management-with-uv)
@@ -111,7 +111,7 @@ The `agent` is model agnostic. The default model is set Chat GTP 4o. We ask the
 Multiple `agents` can form a `team` to complete complex tasks together.
 
 **1. Analysis**
-- Professional `agents` handle the analysis `tasks` on each client, customer, and product. 
+- Professional `agents` handle the analysis `tasks` on each client, customer, and product.
 
 **2. Messaging Workflow Creation**
 - Several `teams` receive the analysis and design initial messaging workflow with several layers.
@@ -122,6 +122,8 @@ Multiple `agents` can form a `team` to complete complex tasks together.
 - Responsible `agents` or `teams` autopilot executing and refining the messaging workflow.
 
 
+<hr />
+
 ## Technologies Used
 **Schema, Database, Data Validation**
    - [Pydantic](https://docs.pydantic.dev/latest/): Data validation and serialization library for Python
@@ -164,14 +166,16 @@ src/
 │      └── ...
 │
 └──tests/
-      └── cli/   
+      └── cli/
       └── team/
       └── ...
-      │        
+      │
       └── uploads/    # Uploaded files for the project
 
 ```
 
+<hr />
+
 ## Setup
 
 1. Install the `uv` package manager:
@@ -204,53 +208,67 @@ src/
    COMPOSIO_CLI_KEY=your-composio-cli-key
    ```
 
-## Usage
+<hr />
 
-1. Add features.
+## Usage
 
-2. Test the features using the `tests` directory.
+1. Install `versionhq` package:
+```
+uv pip install versionhq
+```
 
-- Add a file to the `tests` directory.
-- Run a test.
+2. You can use the `versionhq` module in your Python app.
 ```
-uv run <your file name>
+from versionhq.agent.model import Agent
+agent = Agent(llm="your-llm", ...)
 ```
-* All the `.py` files' names in the `tests` have to be ended with `_test.py`.
 
+For more details:
 
-3. Run a React demo app: [React demo app](https://github.com/versionHQ/test-client-app) to check it on the client endpoint.
-   ```
-   npm i
-   npm start
-   ```
-   The frontend will be available at `http://localhost:3000`.
+[PyPi package](https://pypi.org/project/versionhq/)
 
-4. `production` is available at `https://versi0n.io`. Currently, we are running beta.
+<hr />
 
+## Contributing
 
-## Installing as a Package Module (Alpha)
+1. Fork the repository
 
-1. Open another terminal, set your repository as root, and run
-```
-uv pip install git+https://github.com/versionHQ/multi-agent-system.git#egg=versionhq
-```
+2. Create your feature branch (`git checkout -b feature/your-amazing-feature`)
 
-2. You can use the `versionhq` module in your Python app.
-```
-from versionhq.agent.model import Agent
-agent = Agent(llm="your-llm"...)
-```
+3. Create amazing features
 
-## Contributing & Customizing
+4. Test the features using the `tests` directory.
 
-1. Fork the repository
-2. Create your feature branch (`git checkout -b feature/your-amazing-feature`)
-3. Pull the latest version of source code from the main branch (`git pull origin main`) *Address conflicts if any.
-4. Commit your changes (`git add .` / `git commit -m 'Add your-amazing-feature'`)
-5. Push to the branch (`git push origin feature/your-amazing-feature`)
-6. Open a pull request
+   - Add a test function to respective components in the `tests` directory.
+   - Add your `LITELLM_API_KEY` and `OPENAI_API_KEY` to the Github `repository secrets` @ settings > secrets & variables > Actions.
+   - Run a test.
+      ```
+      uv run pytest tests -vv
+      ```
+
+   **pytest**
+
+   * When adding a new file to `tests`, name the file ended with `_test.py`.
+   * When adding a new feature to the file, name the feature started with `test_`.
+
+5. Pull the latest version of source code from the main branch (`git pull origin main`) *Address conflicts if any.
+6. Commit your changes (`git add .` / `git commit -m 'Add your-amazing-feature'`)
+7. Push to the branch (`git push origin feature/your-amazing-feature`)
+8. Open a pull request
+
+
+**Optional**
+* Flag with `#! REFINEME` for any improvements needed and `#! FIXME` for any errors.
+
+* Run a React demo app: [React demo app](https://github.com/versionHQ/test-client-app) to check it on the client endpoint.
+   ```
+   npm i
+   npm start
+   ```
+   The frontend will be available at `http://localhost:3000`.
+
+* `production` is available at `https://versi0n.io`. Currently, we are running alpha test.
 
-0. Flag with `#! REFINEME` for any improvements and `#! FIXME` for any errors.
 
 
 ### Customizing AI Agents
@@ -299,16 +317,20 @@ Pre-commit hooks help maintain code quality by running checks for formatting, li
    git commit --no-verify -m "your-commit-message"
    ```
 
+<hr />
+
 ## Trouble Shooting
 
 Common issues and solutions:
 - API key errors: Ensure all API keys in the `.env` file are correct and up to date. Make sure to add `load_dotenv()` on the top of the python file to apply the latest environment values.
 - Database connection issues: Check if the Chroma DB is properly initialized and accessible.
 - Memory errors: If processing large contracts, you may need to increase the available memory for the Python process.
-- Issues related to dependencies:`rm -rf .venv uv.lock`, `uv cache clean`  and run `uv run pip install -r requirements.txt -v`.
+- Issues related to dependencies: `rm -rf uv.lock`, `uv cache clean`, `uv venv`, and run `uv pip install -r requirements.txt -v`.
 - Issues related to the AI agents or RAG system: Check the `output.log` file for detailed error messages and stack traces.
 - Issues related to `Python quit unexpectedly`: Check [this stackoverflow article](https://stackoverflow.com/questions/59888499/macos-catalina-python-quit-unexpectedly-error).
+- `reportMissingImports` error from pyright after installing the package: This might occur when installing new libraries while VSCode is running. Open the command pallete (ctrl + shift + p) and run the Python: Restart language server task.
 
+<hr />
 
 ## Frequently Asked Questions (FAQ)
 **Q. Where can I see if the agent is working?**