langroid 0.1.165__tar.gz → 0.1.167__tar.gz

{langroid-0.1.165 → langroid-0.1.167}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.165
+Version: 0.1.167
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Provides-Extra: hf-embeddings
 Provides-Extra: litellm
 Provides-Extra: mysql
+Provides-Extra: neo4j
 Provides-Extra: postgres
 Provides-Extra: sciphi
 Requires-Dist: agent-search (>=0.0.7,<0.0.8) ; extra == "sciphi"
@@ -48,6 +49,7 @@ Requires-Dist: mkdocs-section-index (>=0.3.5,<0.4.0)
 Requires-Dist: mkdocstrings[python] (>=0.21.2,<0.22.0)
 Requires-Dist: momento (>=1.10.2,<2.0.0)
 Requires-Dist: mypy (>=1.7.0,<2.0.0)
+Requires-Dist: neo4j (>=5.14.1,<6.0.0) ; extra == "neo4j"
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: onnxruntime (==1.16.1)
 Requires-Dist: openai (>=1.2.3,<2.0.0)
@@ -138,6 +140,10 @@ This Multi-Agent paradigm is inspired by the
 `Langroid` is a fresh take on LLM app-development, where considerable thought has gone 
 into simplifying the developer experience; it does not use `Langchain`.
 
+:fire: See this [Intro to Langroid](https://lancedb.substack.com/p/langoid-multi-agent-programming-framework)
+blog post from the LanceDB team
+
+
 We welcome contributions -- See the [contributions](./CONTRIBUTING.md) document
 for ideas on what to contribute.
 

{langroid-0.1.165 → langroid-0.1.167}/README.md

@@ -45,6 +45,10 @@ This Multi-Agent paradigm is inspired by the
 `Langroid` is a fresh take on LLM app-development, where considerable thought has gone 
 into simplifying the developer experience; it does not use `Langchain`.
 
+:fire: See this [Intro to Langroid](https://lancedb.substack.com/p/langoid-multi-agent-programming-framework)
+blog post from the LanceDB team
+
+
 We welcome contributions -- See the [contributions](./CONTRIBUTING.md) document
 for ideas on what to contribute.
 

{langroid-0.1.165 → langroid-0.1.167}/langroid/agent/chat_agent.py

@@ -207,26 +207,8 @@ class ChatAgent(Agent):
                 if msg_cls.default_value("request") in self.llm_tools_usable
             ]
         )
-        return textwrap.dedent(
-            f"""
-            === ALL AVAILABLE TOOLS and THEIR JSON FORMAT INSTRUCTIONS ===
-            You have access to the following TOOLS to accomplish your task:
-
-            {json_instructions}
-            
-            When one of the above TOOLs is applicable, you must express your 
-            request as "TOOL:" followed by the request in the above JSON format.
-            """
-            + """
-            The JSON format will be:
-                \\{
-                    "request": "<tool_name>",
-                    "<arg1>": <value1>,
-                    "<arg2>": <value2>,
-                    ...
-                \\}             
-            ----------------------------
-            """.lstrip()
+        return ToolMessage.json_group_instructions().format(
+            json_instructions=json_instructions
         )
 
     def tool_instructions(self) -> str:

{langroid-0.1.165 → langroid-0.1.167}/langroid/agent/chat_document.py

@@ -192,6 +192,16 @@ class ChatDocument(Document):
         if isinstance(message, ChatDocument):
             content = message.content
             fun_call = message.function_call
+            if message.metadata.sender == Entity.USER and fun_call is not None:
+                # This may happen when a (parent agent's) LLM generates a
+                # a Function-call, and it ends up being sent to the current task's
+                # LLM (possibly because the function-call is mis-named or has other
+                # issues and couldn't be handled by handler methods).
+                # But a function-call can only be generated by an entity with
+                # Role.ASSISTANT, so we instead put the content of the function-call
+                # in the content of the message.
+                content += " " + str(fun_call)
+                fun_call = None
             sender_name = message.metadata.sender_name
             tool_ids = message.metadata.tool_ids
             tool_id = tool_ids[-1] if len(tool_ids) > 0 else ""

langroid-0.1.167/langroid/agent/special/neo4j/neo4j_chat_agent.py

@@ -0,0 +1,325 @@
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from pydantic import BaseSettings
+from rich import print
+from rich.console import Console
+
+if TYPE_CHECKING:
+    import neo4j
+
+
+from langroid.agent.chat_agent import ChatAgent, ChatAgentConfig
+from langroid.agent.chat_document import ChatDocMetaData, ChatDocument
+from langroid.agent.special.neo4j.utils.system_message import (
+    DEFAULT_NEO4J_CHAT_SYSTEM_MESSAGE,
+    DEFAULT_SYS_MSG,
+    SCHEMA_TOOLS_SYS_MSG,
+)
+from langroid.agent.special.neo4j.utils.tools import (
+    GenerateCypherQueries,
+    GraphDatabaseSchema,
+)
+from langroid.mytypes import Entity
+
+logger = logging.getLogger(__name__)
+
+console = Console()
+
+NEO4J_ERROR_MSG = "There was an error in your Cypher Query"
+
+empty_nodes = "'nodes': []"
+empty_relationships = "'relationships': []"
+not_valid_query_response = [
+    empty_nodes,
+    empty_relationships,
+    NEO4J_ERROR_MSG,
+]
+
+
+class Neo4jSettings(BaseSettings):
+    uri: str = ""
+    username: str = ""
+    password: str = ""
+    database: str = ""
+
+    class Config:
+        # This enables the use of environment variables to set the settings,
+        # e.g. NEO4J_URI, NEO4J_USERNAME, etc.,
+        # which can either be set in a .env file or in the shell via export cmds.
+        env_prefix = "NEO4J_"
+
+
+class Neo4jChatAgentConfig(ChatAgentConfig):
+    neo4j_settings: Neo4jSettings = Neo4jSettings()
+    system_message: str = DEFAULT_NEO4J_CHAT_SYSTEM_MESSAGE
+    kg_schema: Optional[List[Dict[str, Any]]]
+    database_created: bool = False
+    use_schema_tools: bool = False
+    use_functions_api: bool = True
+    use_tools: bool = False
+
+
+class Neo4jChatAgent(ChatAgent):
+    def __init__(self, config: Neo4jChatAgentConfig):
+        """Initialize the Neo4jChatAgent.
+
+        Raises:
+            ValueError: If database information is not provided in the config.
+        """
+        self.config = config
+        self._validate_config()
+        self._import_neo4j()
+        self._initialize_connection()
+        self._init_tool_messages()
+
+    def _validate_config(self) -> None:
+        """Validate the configuration to ensure all necessary fields are present."""
+        assert isinstance(self.config, Neo4jChatAgentConfig)
+        if (
+            self.config.neo4j_settings.username is None
+            and self.config.neo4j_settings.password is None
+            and self.config.neo4j_settings.database
+        ):
+            raise ValueError("Neo4j env information must be provided")
+
+    def _import_neo4j(self) -> None:
+        """Dynamically imports the Neo4j module and sets it as a global variable."""
+        global neo4j
+        try:
+            import neo4j
+        except ImportError:
+            raise ImportError(
+                """
+                neo4j not installed. Please install it via:
+                pip install neo4j.
+                Or when installing langroid, install it with the `neo4j` extra:
+                pip install langroid[neo4j]
+                """
+            )
+
+    def _initialize_connection(self) -> None:
+        """
+        Initializes a connection to the Neo4j database using the configuration settings.
+        """
+        try:
+            assert isinstance(self.config, Neo4jChatAgentConfig)
+            self.driver = neo4j.GraphDatabase.driver(
+                self.config.neo4j_settings.uri,
+                auth=(
+                    self.config.neo4j_settings.username,
+                    self.config.neo4j_settings.password,
+                ),
+            )
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize Neo4j connection: {e}")
+
+    def close(self) -> None:
+        """close the connection"""
+        if self.driver:
+            self.driver.close()
+
+    def retry_query(self, e: Exception, query: str) -> str:
+        """
+        Generate an error message for a failed Cypher query and return it.
+
+        Args:
+            e (Exception): The exception raised during the Cypher query execution.
+            query (str): The Cypher query that failed.
+
+        Returns:
+            str: The error message.
+        """
+        logger.error(f"Cypher Query failed: {query}\nException: {e}")
+
+        # Construct the error message
+        error_message_template = f"""\
+        {NEO4J_ERROR_MSG}: '{query}'
+        {str(e)}
+        Run a new query, correcting the errors.
+        """
+
+        return error_message_template
+
+    def read_query(
+        self, query: str, parameters: Optional[Dict[Any, Any]] = None
+    ) -> str:
+        """
+        Executes a given Cypher query with parameters on the Neo4j database.
+
+        Args:
+            query (str): The Cypher query string to be executed.
+            parameters (Optional[Dict[Any, Any]]): A dictionary of parameters for the
+            query. Defaults to None.
+
+        Returns:
+            str: The result of executing the Cypher query.
+        """
+        response_message = ""
+        if not self.driver:
+            raise ValueError("No database connection is established.")
+
+        try:
+            assert isinstance(self.config, Neo4jChatAgentConfig)
+            with self.driver.session(
+                database=self.config.neo4j_settings.database
+            ) as session:
+                result = session.run(query, parameters)
+                # Check if there are records in the result
+                if result.peek():
+                    response_message = ", ".join(
+                        [str(record.data()) for record in result]
+                    )
+                else:
+                    response_message = "No records found."
+        except Exception as e:
+            logger.error(f"Failed to execute query: {query}\n{e}")
+            response_message = self.retry_query(e, query)
+        finally:
+            self.close()
+
+        return response_message
+
+    def write_query(
+        self, query: str, parameters: Optional[Dict[Any, Any]] = None
+    ) -> bool:
+        """
+        Executes a write transaction using a given Cypher query on the Neo4j database.
+        This method should be used for queries that modify the database.
+
+        Args:
+            query (str): The Cypher query string to be executed.
+            parameters (dict, optional): A dict of parameters for the Cypher query
+
+        Returns:
+            bool: True if the query was executed successfully, False otherwise.
+        """
+        if not self.driver:
+            raise ValueError("No database connection is established.")
+        response = False
+        try:
+            assert isinstance(self.config, Neo4jChatAgentConfig)
+            with self.driver.session(
+                database=self.config.neo4j_settings.database
+            ) as session:
+                # Execute the query within a write transaction
+                session.write_transaction(lambda tx: tx.run(query, parameters))
+                response = True
+        except Exception as e:
+            logging.warning(
+                f"An unexpected error occurred while executing the write query: {e}"
+            )
+        finally:
+            self.close()
+        return response
+
+    # TODO: test under enterprise edition because community edition doesn't allow
+    # database creation/deletion
+    def remove_database(self) -> None:
+        """Deletes all nodes and relationships from the current Neo4j database."""
+        delete_query = """
+                MATCH (n)
+                DETACH DELETE n
+            """
+        if self.write_query(delete_query):
+            print("[green]Database is deleted!")
+        else:
+            print("[red]Database is not deleted!")
+
+    def make_query(self, msg: GenerateCypherQueries) -> str:
+        """ "
+        Handle a GenerateCypherQueries message by executing a Cypher query and
+        returning the result.
+        Args:
+            msg (GenerateCypherQueries): The tool-message to handle.
+
+        Returns:
+            str: The result of executing the Cypherquery.
+        """
+        query = msg.cypherQuery
+
+        logger.info(f"Executing Cypher query: {query}")
+        return self.read_query(query)
+
+    # TODO: There are various ways to get the schema. The current one uses the func
+    # `read_query`, which requires post processing to identify whether the response upon
+    # the schema query is valid. Another way is to isolate this func from `read_query`.
+    # The current query works well. But we could use the queries here:
+    # https://github.com/neo4j/NaLLM/blob/1af09cd117ba0777d81075c597a5081583568f9f/api/
+    # src/driver/neo4j.py#L30
+    def get_schema(self, msg: GraphDatabaseSchema | None) -> str:
+        """
+        Retrieves the schema of a Neo4j graph database.
+
+        Args:
+            msg (GraphDatabaseSchema): An instance of GraphDatabaseSchema, typically
+            containing information or parameters needed for the database query.
+
+        Returns:
+            str: The visual representation of the database schema as a string, or a
+            message stating that the database schema is empty or not valid.
+
+        Raises:
+            This function does not explicitly raise exceptions but depends on the
+            behavior of 'self.read_query' method, which might raise exceptions related
+             to database connectivity or query execution.
+        """
+        schema = self.read_query("CALL db.schema.visualization()")
+        if not any(element in schema for element in not_valid_query_response):
+            return schema
+        else:
+            return "The database schema does not have any nodes or relationships."
+
+    def _init_tool_messages(self) -> None:
+        """Initialize message tools used for chatting."""
+        message = self._format_message()
+        self.config.system_message = self.config.system_message.format(mode=message)
+        super().__init__(self.config)
+        self.enable_message(GenerateCypherQueries)
+        self.enable_message(GraphDatabaseSchema)
+
+    def _format_message(self) -> str:
+        if self.driver is None:
+            raise ValueError("Database driver None")
+        assert isinstance(self.config, Neo4jChatAgentConfig)
+        return (
+            SCHEMA_TOOLS_SYS_MSG.format(schema=self.get_schema(None))
+            if self.config.use_schema_tools
+            else DEFAULT_SYS_MSG
+        )
+
+    def agent_response(
+        self,
+        msg: Optional[str | ChatDocument] = None,
+    ) -> Optional[ChatDocument]:
+        if msg is None:
+            return None
+
+        results = self.handle_message(msg)
+        if results is None:
+            return None
+
+        output = results
+        if NEO4J_ERROR_MSG in output:
+            output = "There was an error in the Cypher Query. Press enter to retry."
+
+        console.print(f"[red]{self.indent}", end="")
+        print(f"[red]Agent: {output}")
+        sender_name = self.config.name
+        if isinstance(msg, ChatDocument) and msg.function_call is not None:
+            sender_name = msg.function_call.name
+
+        content = results.content if isinstance(results, ChatDocument) else results
+        recipient = (
+            results.metadata.recipient if isinstance(results, ChatDocument) else ""
+        )
+
+        return ChatDocument(
+            content=content,
+            metadata=ChatDocMetaData(
+                # source=Entity.AGENT,
+                sender=Entity.LLM,
+                sender_name=sender_name,
+                recipient=recipient,
+            ),
+        )

langroid-0.1.167/langroid/agent/special/neo4j/utils/system_message.py

@@ -0,0 +1,39 @@
+SCHEMA_TOOLS_SYS_MSG = """You are a data scientist and expert in Knolwedge Graphs, 
+with expertise in answering questions by interacting with a Neo4j graph database.
+
+The schema maps the Neo4j database structure. node labels, relationship types,
+and property keys available in your Neo4j database. 
+{schema}
+Do not make assumptions about the database schema before using the tools.
+Use the tool/function to learn more about the database schema."""
+
+DEFAULT_SYS_MSG = """You are a data scientist and expert in Knolwedge Graphs, 
+with expertise in answering questions by querying Neo4j database.
+You do not have access to the database directly, so you will need to use the 
+`make_query` tool/function-call to answer questions.
+
+Use the `get_schema` tool/function-call to get all the node labels, relationship types,
+ and property keys available in your Neo4j database.
+
+ONLY the node labels, relationship types, and property keys listed in the specified 
+above should be used in the generated queries. 
+You must be smart about using the right node labels, relationship types, and property
+keys based on the english description. If you are thinking of using a node label,
+relationship type, or property key that does not exist, you are probably on the wrong 
+track, so you should try your best to answer based on an existing table or column.
+DO NOT assume any nodes or relationships other than those above."""
+
+DEFAULT_NEO4J_CHAT_SYSTEM_MESSAGE = """
+{mode}
+
+You do not need to attempt answering a question with just one query. 
+You could make a sequence of Neo4j queries to help you write the final query.
+Also if you receive a null or other unexpected result,
+(a) make sure you use the available TOOLs correctly, and 
+(b) see if you have made an assumption in your Neo4j query, and try another way, 
+   or use `run_query` to explore the database contents before submitting your 
+   final query. 
+
+Start by asking what I would like to know about the data.
+
+"""

langroid-0.1.167/langroid/agent/special/neo4j/utils/tools.py

@@ -0,0 +1,13 @@
+from langroid.agent.tool_message import ToolMessage
+
+
+class GenerateCypherQueries(ToolMessage):
+    request: str = "make_query"
+    purpose: str = """Use this tool to send me the Generated Cypher query based on 
+    text description and schema that I will provide you."""
+    cypherQuery: str
+
+
+class GraphDatabaseSchema(ToolMessage):
+    request: str = "get_schema"
+    purpose: str = """Use this tool to get me the schema of the graph database."""

{langroid-0.1.165 → langroid-0.1.167}/langroid/agent/tool_message.py

@@ -103,7 +103,7 @@ class ToolMessage(ABC, BaseModel):
     @classmethod
     def json_instructions(cls) -> str:
         """
-        Default Instructions to the LLM showing how to use the message.
+        Default Instructions to the LLM showing how to use the tool/function-call.
         Works for GPT4 but override this for weaker LLMs if needed.
         Returns:
             str: instructions on how to use the message
@@ -122,6 +122,23 @@ class ToolMessage(ABC, BaseModel):
             """.lstrip()
         )
 
+    @staticmethod
+    def json_group_instructions() -> str:
+        """Template for instructions for a group of tools.
+        Works with GPT4 but override this for weaker LLMs if needed.
+        """
+        return textwrap.dedent(
+            """
+            === ALL AVAILABLE TOOLS and THEIR JSON FORMAT INSTRUCTIONS ===
+            You have access to the following TOOLS to accomplish your task:
+
+            {json_instructions}
+            
+            When one of the above TOOLs is applicable, you must express your 
+            request as "TOOL:" followed by the request in the above JSON format.
+            """
+        )
+
     @classmethod
     def llm_function_schema(
         cls,

{langroid-0.1.165 → langroid-0.1.167}/langroid/language_models/base.py

@@ -3,11 +3,12 @@ import asyncio
 import json
 import logging
 from abc import ABC, abstractmethod
+from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 import aiohttp
-from pydantic import BaseModel, BaseSettings
+from pydantic import BaseModel, BaseSettings, Field
 
 from langroid.cachedb.momento_cachedb import MomentoCacheConfig
 from langroid.cachedb.redis_cachedb import RedisCacheConfig
@@ -135,6 +136,7 @@ class LLMMessage(BaseModel):
     tool_id: str = ""  # used by OpenAIAssistant
     content: str
     function_call: Optional[LLMFunctionCall] = None
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
 
     def api_dict(self) -> Dict[str, Any]:
         """
@@ -157,6 +159,7 @@ class LLMMessage(BaseModel):
                     dict_no_none["function_call"]["arguments"]
                 )
         dict_no_none.pop("tool_id", None)
+        dict_no_none.pop("timestamp", None)
         return dict_no_none
 
     def __str__(self) -> str:

{langroid-0.1.165 → langroid-0.1.167}/langroid/language_models/openai_gpt.py

@@ -931,7 +931,7 @@ class OpenAIGPT(LanguageModel):
                 self._cache_store(hashed_key, result.model_dump())
         return cached, hashed_key, result
 
-    @retry_with_exponential_backoff
+    @async_retry_with_exponential_backoff
     async def _achat_completions_with_backoff(self, **kwargs):  # type: ignore
         cached = False
         hashed_key, result = self._cache_lookup("Completion", **kwargs)

{langroid-0.1.165 → langroid-0.1.167}/langroid/parsing/document_parser.py

@@ -19,6 +19,7 @@ logger = logging.getLogger(__name__)
 class DocumentType(str, Enum):
     PDF = "pdf"
     DOCX = "docx"
+    DOC = "doc"
 
 
 class DocumentParser(Parser):
@@ -68,6 +69,8 @@ class DocumentParser(Parser):
                 raise ValueError(
                     f"Unsupported DOCX library specified: {config.docx.library}"
                 )
+        elif DocumentParser._document_type(source) == DocumentType.DOC:
+            return UnstructuredDocParser(source, config)
         else:
             raise ValueError(f"Unsupported document type: {source}")
 
@@ -98,6 +101,8 @@ class DocumentParser(Parser):
             return DocumentType.PDF
         elif source.lower().endswith(".docx"):
             return DocumentType.DOCX
+        elif source.lower().endswith(".doc"):
+            return DocumentType.DOC
         else:
             raise ValueError(f"Unsupported document type: {source}")
 
@@ -440,6 +445,27 @@ class UnstructuredDocxParser(DocumentParser):
         return self.fix_text(text)
 
 
+class UnstructuredDocParser(UnstructuredDocxParser):
+    def iterate_pages(self) -> Generator[Tuple[int, Any], None, None]:  # type: ignore
+        from unstructured.partition.doc import partition_doc
+
+        elements = partition_doc(filename=self.source, include_page_breaks=True)
+
+        page_number = 1
+        page_elements = []  # type: ignore
+        for el in elements:
+            if el.category == "PageBreak":
+                if page_elements:  # Avoid yielding empty pages at the start
+                    yield page_number, page_elements
+                page_number += 1
+                page_elements = []
+            else:
+                page_elements.append(el)
+        # Yield the last page if it's not empty
+        if page_elements:
+            yield page_number, page_elements
+
+
 class PythonDocxParser(DocumentParser):
     """
     Parser for processing DOCX files using the `python-docx` library.

{langroid-0.1.165 → langroid-0.1.167}/langroid/parsing/parser.py

@@ -28,6 +28,10 @@ class DocxParsingConfig(BaseSettings):
     library: Literal["python-docx", "unstructured"] = "unstructured"
 
 
+class DocParsingConfig(BaseSettings):
+    library: Literal["unstructured"] = "unstructured"
+
+
 class ParsingConfig(BaseSettings):
     splitter: str = Splitter.TOKENS
     chunk_size: int = 200  # aim for this many tokens per chunk
@@ -42,6 +46,7 @@ class ParsingConfig(BaseSettings):
     token_encoding_model: str = "text-embedding-ada-002"
     pdf: PdfParsingConfig = PdfParsingConfig()
     docx: DocxParsingConfig = DocxParsingConfig()
+    doc: DocParsingConfig = DocParsingConfig()
 
 
 class Parser:

{langroid-0.1.165 → langroid-0.1.167}/langroid/parsing/repo_loader.py

@@ -545,7 +545,7 @@ class RepoLoader:
 
         for file_path in file_paths:
             _, file_extension = os.path.splitext(file_path)
-            if file_extension.lower() in [".pdf", ".docx"]:
+            if file_extension.lower() in [".pdf", ".docx", ".doc"]:
                 doc_parser = DocumentParser.create(
                     file_path,
                     parser.config,

{langroid-0.1.165 → langroid-0.1.167}/langroid/parsing/url_loader.py

@@ -44,7 +44,11 @@ class URLLoader:
                 sleep_time=5,
             )
             for url, result in buffered_downloads(buffer, threads):
-                if url.lower().endswith(".pdf") or url.lower().endswith(".docx"):
+                if (
+                    url.lower().endswith(".pdf")
+                    or url.lower().endswith(".docx")
+                    or url.lower().endswith(".doc")
+                ):
                     doc_parser = DocumentParser.create(
                         url,
                         self.parser.config,

{langroid-0.1.165 → langroid-0.1.167}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.1.165"
+version = "0.1.167"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -81,6 +81,7 @@ scrapy = "^2.11.0"
 async-generator = "^1.10"
 lancedb = "^0.4.1"
 pytest-redis = "^3.0.2"
+neo4j = {version = "^5.14.1", optional = true}
 agent-search = {version = "^0.0.7", optional = true}
 python-docx = "^1.1.0"
 aiohttp = "^3.9.1"
@@ -91,6 +92,7 @@ hf-embeddings = ["sentence-transformers", "torch"]
 postgres = ["psycopg2", "pytest-postgresql"]
 mysql = ["pymysql", "pytest-mysql"]
 litellm = ["litellm"]
+neo4j = ["neo4j"]
 sciphi = ["agent-search"]