aions-llm 1.0.0__tar.gz

aions_llm-1.0.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: aions-llm
+Version: 1.0.0
+Summary: Actions and Interface Object Notation: An open standard for LLM tools.
+Author: Sourav Modak
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: langchain>=0.1.0
+
+# AIONS: Actions and Interface Object Notation
+
+**AIONS** (pronounced *IONS*) is an open-standard, text-based data format designed specifically for AI Large Language Models (LLMs). It allows developers to decouple tool definitions from core logic, making AI "Actions" as portable as JSON but as powerful as native Python.
+
+## 🛠 Why AIONS?
+
+Traditional AI tool registration often involves bloating your Python files with massive strings for descriptions and repetitive boilerplate. AIONS solves this by:
+*   **Decoupling:** Move your LLM prompts (descriptions) and tool mappings into external `.aion` files.
+*   **Dynamic Evaluation:** Supports native Python lambdas and complex logic directly within the notation.
+*   **Strict Validation:** Enforces a rigid property schema to prevent "ghost tools" or broken agent execution.
+*   **Zero-Map Architecture:** No need to maintain manual dictionaries; if it’s in the `.aion` file, it’s in your Agent.
+
+---
+
+## 📜 The Laws of AIONS
+
+To maintain the "Open Standard" integrity, every `.aion` file must adhere to the following rules:
+
+### 1. The Array Constraint
+An AIONS definition must always be an array, enclosed in square brackets `[ ]`. Even if you are defining a single tool, it must reside within an array.
+
+### 2. The Arrow Operator
+Properties are assigned using the "Action-Link" operator: `-->`. 
+*   **Valid:** `name --> "MyTool"`
+*   **Invalid:** `name: "MyTool"` or `name = "MyTool"`
+
+### 3. Property Isolation
+AIONS strictly enforces identified properties. If the parser encounters a top-level key that is not in the **Approved Registry**, it will throw an `AIONPropertyError`.
+*   **Approved Registry:** `name`, `function`, `description`, `args_schema`.
+
+### 4. The Function Block
+The `function` property is a "Smart Property." It requires a raw string representing the executable (lambda or function name) followed by an "Interface Block" `{ }` describing the inputs and outputs.
+*   Inputs must follow the `arg-N` pattern.
+*   Outputs must follow the `return-N` pattern.
+
+---
+
+## 📂 Syntax Example
+### 📝 AIONS Syntax Guide
+
+The AIONS (Actions and Interface Object Notation) syntax is designed to be strictly structural yet human-readable. It follows a specific set of rules to ensure LLM compatibility and execution safety.
+
+#### 1. Global Wrapper
+All tool definitions must be contained within a root-level array:
+`[` ... `]`
+
+#### 2. Tool Objects
+Individual tools are defined as objects within curly braces:
+`{` ... `}`
+
+#### 3. The Action-Link Operator (-->)
+AIONS uses the `-->` operator to map keys to values. Standard colon `:` or equals `=` assignments are invalid and will trigger a parse error.
+
+#### 4. Top-Level Properties
+Every tool object must contain the following identified properties:
+*   **name**: The unique identifier for the tool.
+*   **function**: The executable logic and interface mapping.
+*   **args_schema** (Optional): The Pydantic class name for input validation.
+*   **description**: The natural language instruction for the LLM.
+
+#### 5. The Smart Function Block
+The `function` property is split into two parts:
+1.  **Executable String**: The lambda or function name (e.g., `"lambda x: func(x)"`).
+2.  **Interface Block**: A nested `{}` mapping that defines parameters and returns.
+
+#### 💡 Syntax Template:
+```text
+{
+ name --> "Unique_Tool_Name",
+ function --> "executable_python_logic" --> {
+      arg-1 --> "Input description",
+      return-1 --> "Output description"
+ },
+ args_schema --> "PydanticClassName",
+ description --> "Detailed prompt for the AI agent"
+}
+```
+
+## 🚀 Getting Started
+1. Project Structure
+Keep your tools organized. We recommend an aion_tools/ directory for modularity.
+
+```text
+from aions import AIONS
+import api_functions
+from schemas import SendLikeInput
+
+# 1. Load your tools with context
+# 'globals()' allows AIONS to find your imported functions and schemas in memory
+tools = AIONS.get_langchain_tools(
+    source_path="aion_tools/", 
+    context=globals()
+)
+
+# 2. Pass them directly to your Agent
+# agent = initialize_agent(tools, llm, ...)
+```
+
+## 2. Integration with LangChain
+AIONS is built to be a first-class citizen in the LangChain ecosystem.
+
+```text
+from aions import AIONS
+import api_functions
+from schemas import SendLikeInput
+
+# 1. Load your tools with context
+# 'globals()' allows AIONS to find your imported functions and schemas
+tools = AIONS.get_langchain_tools(
+    source_path="aion_tools/", 
+    context=globals()
+)
+
+# 2. Pass them directly to your Agent
+# agent = initialize_agent(tools, llm, ...)
+```
+
+## ⚖️ Error Handling
+
+AIONS is designed to fail fast. This prevents your AI Agent from attempting to use a tool that was configured incorrectly.
+
+| Error | Cause |
+| :--- | :--- |
+| `AIONPropertyError` | Using an unauthorized key (e.g., using `desc` instead of `description`). |
+| `AIONParseError` | Syntax errors, missing brackets, or function strings that don't exist in your Python code. |
+
+## 🛠 Extending the Framework
+The AIONS class provides several utility methods for different workflows:
+
+```text
+load_dir(path, context): Automatically stitches together all .aion files in a folder.
+
+dumps(list_of_tools): Converts existing Python tool dictionaries into the AIONS standard text format.
+
+get_langchain_tools(...): The high-level factory for instant LangChain mounting.
+``` 
+## 🤝 Contributing
+AIONS is an open standard. Feel free to fork the framework and add support for other LLM frameworks.
+
+Developed by Sourav Modak

aions_llm-1.0.0/README.md

@@ -0,0 +1,140 @@
+# AIONS: Actions and Interface Object Notation
+
+**AIONS** (pronounced *IONS*) is an open-standard, text-based data format designed specifically for AI Large Language Models (LLMs). It allows developers to decouple tool definitions from core logic, making AI "Actions" as portable as JSON but as powerful as native Python.
+
+## 🛠 Why AIONS?
+
+Traditional AI tool registration often involves bloating your Python files with massive strings for descriptions and repetitive boilerplate. AIONS solves this by:
+*   **Decoupling:** Move your LLM prompts (descriptions) and tool mappings into external `.aion` files.
+*   **Dynamic Evaluation:** Supports native Python lambdas and complex logic directly within the notation.
+*   **Strict Validation:** Enforces a rigid property schema to prevent "ghost tools" or broken agent execution.
+*   **Zero-Map Architecture:** No need to maintain manual dictionaries; if it’s in the `.aion` file, it’s in your Agent.
+
+---
+
+## 📜 The Laws of AIONS
+
+To maintain the "Open Standard" integrity, every `.aion` file must adhere to the following rules:
+
+### 1. The Array Constraint
+An AIONS definition must always be an array, enclosed in square brackets `[ ]`. Even if you are defining a single tool, it must reside within an array.
+
+### 2. The Arrow Operator
+Properties are assigned using the "Action-Link" operator: `-->`. 
+*   **Valid:** `name --> "MyTool"`
+*   **Invalid:** `name: "MyTool"` or `name = "MyTool"`
+
+### 3. Property Isolation
+AIONS strictly enforces identified properties. If the parser encounters a top-level key that is not in the **Approved Registry**, it will throw an `AIONPropertyError`.
+*   **Approved Registry:** `name`, `function`, `description`, `args_schema`.
+
+### 4. The Function Block
+The `function` property is a "Smart Property." It requires a raw string representing the executable (lambda or function name) followed by an "Interface Block" `{ }` describing the inputs and outputs.
+*   Inputs must follow the `arg-N` pattern.
+*   Outputs must follow the `return-N` pattern.
+
+---
+
+## 📂 Syntax Example
+### 📝 AIONS Syntax Guide
+
+The AIONS (Actions and Interface Object Notation) syntax is designed to be strictly structural yet human-readable. It follows a specific set of rules to ensure LLM compatibility and execution safety.
+
+#### 1. Global Wrapper
+All tool definitions must be contained within a root-level array:
+`[` ... `]`
+
+#### 2. Tool Objects
+Individual tools are defined as objects within curly braces:
+`{` ... `}`
+
+#### 3. The Action-Link Operator (-->)
+AIONS uses the `-->` operator to map keys to values. Standard colon `:` or equals `=` assignments are invalid and will trigger a parse error.
+
+#### 4. Top-Level Properties
+Every tool object must contain the following identified properties:
+*   **name**: The unique identifier for the tool.
+*   **function**: The executable logic and interface mapping.
+*   **args_schema** (Optional): The Pydantic class name for input validation.
+*   **description**: The natural language instruction for the LLM.
+
+#### 5. The Smart Function Block
+The `function` property is split into two parts:
+1.  **Executable String**: The lambda or function name (e.g., `"lambda x: func(x)"`).
+2.  **Interface Block**: A nested `{}` mapping that defines parameters and returns.
+
+#### 💡 Syntax Template:
+```text
+{
+ name --> "Unique_Tool_Name",
+ function --> "executable_python_logic" --> {
+      arg-1 --> "Input description",
+      return-1 --> "Output description"
+ },
+ args_schema --> "PydanticClassName",
+ description --> "Detailed prompt for the AI agent"
+}
+```
+
+## 🚀 Getting Started
+1. Project Structure
+Keep your tools organized. We recommend an aion_tools/ directory for modularity.
+
+```text
+from aions import AIONS
+import api_functions
+from schemas import SendLikeInput
+
+# 1. Load your tools with context
+# 'globals()' allows AIONS to find your imported functions and schemas in memory
+tools = AIONS.get_langchain_tools(
+    source_path="aion_tools/", 
+    context=globals()
+)
+
+# 2. Pass them directly to your Agent
+# agent = initialize_agent(tools, llm, ...)
+```
+
+## 2. Integration with LangChain
+AIONS is built to be a first-class citizen in the LangChain ecosystem.
+
+```text
+from aions import AIONS
+import api_functions
+from schemas import SendLikeInput
+
+# 1. Load your tools with context
+# 'globals()' allows AIONS to find your imported functions and schemas
+tools = AIONS.get_langchain_tools(
+    source_path="aion_tools/", 
+    context=globals()
+)
+
+# 2. Pass them directly to your Agent
+# agent = initialize_agent(tools, llm, ...)
+```
+
+## ⚖️ Error Handling
+
+AIONS is designed to fail fast. This prevents your AI Agent from attempting to use a tool that was configured incorrectly.
+
+| Error | Cause |
+| :--- | :--- |
+| `AIONPropertyError` | Using an unauthorized key (e.g., using `desc` instead of `description`). |
+| `AIONParseError` | Syntax errors, missing brackets, or function strings that don't exist in your Python code. |
+
+## 🛠 Extending the Framework
+The AIONS class provides several utility methods for different workflows:
+
+```text
+load_dir(path, context): Automatically stitches together all .aion files in a folder.
+
+dumps(list_of_tools): Converts existing Python tool dictionaries into the AIONS standard text format.
+
+get_langchain_tools(...): The high-level factory for instant LangChain mounting.
+``` 
+## 🤝 Contributing
+AIONS is an open standard. Feel free to fork the framework and add support for other LLM frameworks.
+
+Developed by Sourav Modak

aions_llm-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aions-llm"
+version = "1.0.0"
+authors = [
+  { name="Sourav Modak" },
+]
+description = "Actions and Interface Object Notation: An open standard for LLM tools."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "langchain>=0.1.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

aions_llm-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aions_llm-1.0.0/src/aions/__init__.py

@@ -0,0 +1,3 @@
+from .aions import AIONS, AIONParseError, AIONPropertyError
+
+__all__ = ['AIONS', 'AIONParseError', 'AIONPropertyError']

aions_llm-1.0.0/src/aions/aions.py

@@ -0,0 +1,167 @@
+import os
+import re
+from typing import Any, Dict, List
+
+
+class AIONPropertyError(Exception):
+    """Raised when an unidentified property is found in the .aion file."""
+    pass
+
+
+class AIONParseError(Exception):
+    """Raised when the syntax of the .aion file is invalid."""
+    pass
+
+
+class AIONS:
+    # Expanded properties to include LangChain's args_schema
+    ALLOWED_PROPERTIES = {"name", "function", "description", "args_schema"}
+
+    @classmethod
+    def loads(cls, aion_text: str, context: Dict[str, Any] = None) -> List[Dict[str, Any]]:
+        aion_text = aion_text.strip()
+
+        if not (aion_text.startswith("[") and aion_text.endswith("]")):
+            raise AIONParseError("AION definition must be an array enclosed in [ ]")
+
+        tools = []
+        block_pattern = re.compile(r'\{([^{}]*\{[^{}]*\}[^{}]*|[^{}]*)\}')
+        blocks = block_pattern.findall(aion_text)
+
+        for block in blocks:
+            tool_data = {}
+            found_properties = re.findall(r'([a-zA-Z0-9_-]+)\s*-->', block)
+
+            for prop in set(found_properties):
+                if prop not in cls.ALLOWED_PROPERTIES and not prop.startswith("arg-") and not prop.startswith(
+                        "return-"):
+                    raise AIONPropertyError(f"Error: Property [{prop}] cannot be identified.")
+
+            # Extract Name
+            name_match = re.search(r'name\s*-->\s*"([^"]+)"', block)
+            if name_match:
+                tool_data['name'] = name_match.group(1)
+
+            # Extract Description
+            desc_match = re.search(r'description\s*-->\s*"([^"]+)"', block)
+            if desc_match:
+                tool_data['description'] = desc_match.group(1)
+
+            # Extract Args Schema (New Property)
+            schema_match = re.search(r'args_schema\s*-->\s*"([^"]+)"', block)
+            if schema_match:
+                schema_str = schema_match.group(1)
+                tool_data['args_schema_str'] = schema_str
+                if context:
+                    try:
+                        # Evaluate the string to get the actual Pydantic class
+                        tool_data['args_schema'] = eval(schema_str, context)
+                    except Exception as e:
+                        raise AIONParseError(
+                            f"Could not parse schema '{schema_str}'. Ensure it is in context. Error: {e}")
+
+            # Extract Function Block
+            func_match = re.search(r'function\s*-->\s*"([^"]+)"\s*-->\s*\{([^}]+)\}', block)
+            if func_match:
+                func_str = func_match.group(1)
+                inner_block = func_match.group(2)
+                func_data = {"raw_string": func_str, "args": {}, "returns": {}}
+
+                if context:
+                    try:
+                        func_data["executable"] = eval(func_str, context)
+                    except Exception as e:
+                        raise AIONParseError(
+                            f"Could not parse function '{func_str}'. Ensure all dependencies are in context. Error: {e}")
+
+                inner_items = re.findall(r'(arg-\d+|return-\d+)\s*-->\s*"([^"]*)"', inner_block)
+                for key, val in inner_items:
+                    if key.startswith("arg-"):
+                        func_data["args"][key] = val
+                    elif key.startswith("return-"):
+                        func_data["returns"][key] = val
+
+                tool_data['function'] = func_data
+
+            tools.append(tool_data)
+
+        return tools
+
+    @classmethod
+    def load(cls, filepath: str, context: Dict[str, Any] = None) -> List[Dict[str, Any]]:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return cls.loads(f.read(), context)
+
+    @classmethod
+    def load_dir(cls, dirpath: str, context: Dict[str, Any] = None) -> List[Dict[str, Any]]:
+        all_tools = []
+        for filename in os.listdir(dirpath):
+            if filename.endswith(".aion"):
+                filepath = os.path.join(dirpath, filename)
+                all_tools.extend(cls.load(filepath, context))
+        return all_tools
+
+    @classmethod
+    def dumps(cls, tools: List[Dict[str, Any]]) -> str:
+        aion_strings = []
+        for tool in tools:
+            aion_str = "  {\n"
+            aion_str += f'   name --> "{tool.get("name", "")}",\n'
+
+            func = tool.get("function", {})
+            aion_str += f'   function --> "{func.get("raw_string", "")}" --> {{\n'
+
+            for arg_k, arg_v in func.get("args", {}).items():
+                aion_str += f'        {arg_k} --> "{arg_v}",\n'
+
+            for ret_k, ret_v in func.get("returns", {}).items():
+                aion_str += f'        {ret_k} --> "{ret_v}",\n'
+
+            aion_str = aion_str.rstrip(",\n") + "\n   },\n"
+
+            # Dump args_schema if it exists
+            if 'args_schema_str' in tool:
+                aion_str += f'   args_schema --> "{tool["args_schema_str"]}",\n'
+
+            aion_str += f'   description --> "{tool.get("description", "")}"\n'
+            aion_str += "  }"
+            aion_strings.append(aion_str)
+
+        return "[\n" + ",\n".join(aion_strings) + "\n]"
+
+    @classmethod
+    def dump(cls, tools: List[Dict[str, Any]], filepath: str):
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(cls.dumps(tools))
+
+    @classmethod
+    def get_langchain_tools(cls, source_path: str, context: Dict[str, Any]) -> list:
+        try:
+            from langchain.agents import Tool
+        except ImportError:
+            raise ImportError("LangChain is not installed. Run 'pip install langchain'")
+
+        if os.path.isdir(source_path):
+            parsed_data = cls.load_dir(source_path, context)
+        elif os.path.isfile(source_path):
+            parsed_data = cls.load(source_path, context)
+        else:
+            raise FileNotFoundError(f"Source '{source_path}' is neither a valid file nor directory.")
+
+        langchain_tools = []
+        for tool_config in parsed_data:
+            tool_name = tool_config["name"]
+            executable_func = tool_config["function"]["executable"]
+
+            # Now extracting schema dynamically from the parsed AION data
+            args_schema = tool_config.get("args_schema")
+
+            tool = Tool(
+                name=tool_name,
+                func=executable_func,
+                description=tool_config["description"],
+                args_schema=args_schema
+            )
+            langchain_tools.append(tool)
+
+        return langchain_tools

aions_llm-1.0.0/src/aions_llm.egg-info/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: aions-llm
+Version: 1.0.0
+Summary: Actions and Interface Object Notation: An open standard for LLM tools.
+Author: Sourav Modak
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: langchain>=0.1.0
+
+# AIONS: Actions and Interface Object Notation
+
+**AIONS** (pronounced *IONS*) is an open-standard, text-based data format designed specifically for AI Large Language Models (LLMs). It allows developers to decouple tool definitions from core logic, making AI "Actions" as portable as JSON but as powerful as native Python.
+
+## 🛠 Why AIONS?
+
+Traditional AI tool registration often involves bloating your Python files with massive strings for descriptions and repetitive boilerplate. AIONS solves this by:
+*   **Decoupling:** Move your LLM prompts (descriptions) and tool mappings into external `.aion` files.
+*   **Dynamic Evaluation:** Supports native Python lambdas and complex logic directly within the notation.
+*   **Strict Validation:** Enforces a rigid property schema to prevent "ghost tools" or broken agent execution.
+*   **Zero-Map Architecture:** No need to maintain manual dictionaries; if it’s in the `.aion` file, it’s in your Agent.
+
+---
+
+## 📜 The Laws of AIONS
+
+To maintain the "Open Standard" integrity, every `.aion` file must adhere to the following rules:
+
+### 1. The Array Constraint
+An AIONS definition must always be an array, enclosed in square brackets `[ ]`. Even if you are defining a single tool, it must reside within an array.
+
+### 2. The Arrow Operator
+Properties are assigned using the "Action-Link" operator: `-->`. 
+*   **Valid:** `name --> "MyTool"`
+*   **Invalid:** `name: "MyTool"` or `name = "MyTool"`
+
+### 3. Property Isolation
+AIONS strictly enforces identified properties. If the parser encounters a top-level key that is not in the **Approved Registry**, it will throw an `AIONPropertyError`.
+*   **Approved Registry:** `name`, `function`, `description`, `args_schema`.
+
+### 4. The Function Block
+The `function` property is a "Smart Property." It requires a raw string representing the executable (lambda or function name) followed by an "Interface Block" `{ }` describing the inputs and outputs.
+*   Inputs must follow the `arg-N` pattern.
+*   Outputs must follow the `return-N` pattern.
+
+---
+
+## 📂 Syntax Example
+### 📝 AIONS Syntax Guide
+
+The AIONS (Actions and Interface Object Notation) syntax is designed to be strictly structural yet human-readable. It follows a specific set of rules to ensure LLM compatibility and execution safety.
+
+#### 1. Global Wrapper
+All tool definitions must be contained within a root-level array:
+`[` ... `]`
+
+#### 2. Tool Objects
+Individual tools are defined as objects within curly braces:
+`{` ... `}`
+
+#### 3. The Action-Link Operator (-->)
+AIONS uses the `-->` operator to map keys to values. Standard colon `:` or equals `=` assignments are invalid and will trigger a parse error.
+
+#### 4. Top-Level Properties
+Every tool object must contain the following identified properties:
+*   **name**: The unique identifier for the tool.
+*   **function**: The executable logic and interface mapping.
+*   **args_schema** (Optional): The Pydantic class name for input validation.
+*   **description**: The natural language instruction for the LLM.
+
+#### 5. The Smart Function Block
+The `function` property is split into two parts:
+1.  **Executable String**: The lambda or function name (e.g., `"lambda x: func(x)"`).
+2.  **Interface Block**: A nested `{}` mapping that defines parameters and returns.
+
+#### 💡 Syntax Template:
+```text
+{
+ name --> "Unique_Tool_Name",
+ function --> "executable_python_logic" --> {
+      arg-1 --> "Input description",
+      return-1 --> "Output description"
+ },
+ args_schema --> "PydanticClassName",
+ description --> "Detailed prompt for the AI agent"
+}
+```
+
+## 🚀 Getting Started
+1. Project Structure
+Keep your tools organized. We recommend an aion_tools/ directory for modularity.
+
+```text
+from aions import AIONS
+import api_functions
+from schemas import SendLikeInput
+
+# 1. Load your tools with context
+# 'globals()' allows AIONS to find your imported functions and schemas in memory
+tools = AIONS.get_langchain_tools(
+    source_path="aion_tools/", 
+    context=globals()
+)
+
+# 2. Pass them directly to your Agent
+# agent = initialize_agent(tools, llm, ...)
+```
+
+## 2. Integration with LangChain
+AIONS is built to be a first-class citizen in the LangChain ecosystem.
+
+```text
+from aions import AIONS
+import api_functions
+from schemas import SendLikeInput
+
+# 1. Load your tools with context
+# 'globals()' allows AIONS to find your imported functions and schemas
+tools = AIONS.get_langchain_tools(
+    source_path="aion_tools/", 
+    context=globals()
+)
+
+# 2. Pass them directly to your Agent
+# agent = initialize_agent(tools, llm, ...)
+```
+
+## ⚖️ Error Handling
+
+AIONS is designed to fail fast. This prevents your AI Agent from attempting to use a tool that was configured incorrectly.
+
+| Error | Cause |
+| :--- | :--- |
+| `AIONPropertyError` | Using an unauthorized key (e.g., using `desc` instead of `description`). |
+| `AIONParseError` | Syntax errors, missing brackets, or function strings that don't exist in your Python code. |
+
+## 🛠 Extending the Framework
+The AIONS class provides several utility methods for different workflows:
+
+```text
+load_dir(path, context): Automatically stitches together all .aion files in a folder.
+
+dumps(list_of_tools): Converts existing Python tool dictionaries into the AIONS standard text format.
+
+get_langchain_tools(...): The high-level factory for instant LangChain mounting.
+``` 
+## 🤝 Contributing
+AIONS is an open standard. Feel free to fork the framework and add support for other LLM frameworks.
+
+Developed by Sourav Modak

aions_llm-1.0.0/src/aions_llm.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/aions/__init__.py
+src/aions/aions.py
+src/aions_llm.egg-info/PKG-INFO
+src/aions_llm.egg-info/SOURCES.txt
+src/aions_llm.egg-info/dependency_links.txt
+src/aions_llm.egg-info/requires.txt
+src/aions_llm.egg-info/top_level.txt

aions_llm-1.0.0/src/aions_llm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aions_llm-1.0.0/src/aions_llm.egg-info/requires.txt

@@ -0,0 +1 @@
+langchain>=0.1.0

aions_llm-1.0.0/src/aions_llm.egg-info/top_level.txt

@@ -0,0 +1 @@
+aions