llama-index-tools-openapi 0.0.1__py3-none-any.whl

llama_index/tools/openapi/__init__.py

@@ -0,0 +1,6 @@
+# __init__.py
+from llama_index.tools.openapi.base import (
+    OpenAPIToolSpec,
+)
+
+__all__ = ["OpenAPIToolSpec"]

llama_index/tools/openapi/base.py

@@ -0,0 +1,117 @@
+"""OpenAPI Tool."""
+
+from typing import List, Optional
+
+import requests
+
+from llama_index.core.schema import Document
+from llama_index.core.tools.tool_spec.base import BaseToolSpec
+
+
+class OpenAPIToolSpec(BaseToolSpec):
+    """OpenAPI Tool
+
+    This tool can be used to parse an OpenAPI spec for endpoints and operations
+    Use the RequestsToolSpec to automate requests to the openapi server
+    """
+
+    spec_functions = ["load_openapi_spec"]
+
+    def __init__(self, spec: Optional[dict] = None, url: Optional[str] = None):
+        import yaml
+
+        if spec and url:
+            raise ValueError("Only provide one of OpenAPI dict or url")
+        elif spec:
+            pass
+        elif url:
+            response = requests.get(url).text
+            spec = yaml.safe_load(response)
+        else:
+            raise ValueError("You must provide a url or OpenAPI spec as a dict")
+
+        parsed_spec = self.process_api_spec(spec)
+        self.spec = Document(text=str(parsed_spec))
+
+    def load_openapi_spec(self) -> List[Document]:
+        """
+        You are an AI agent specifically designed to retrieve information by making web requests to an API based on an OpenAPI specification.
+
+        Here's a step-by-step guide to assist you in answering questions:
+
+        1. Determine the base URL required for making the request
+
+        2. Identify the relevant paths necessary to address the question
+
+        3. Find the required parameters for making the request
+
+        4. Perform the necessary requests to obtain the answer
+
+        Returns:
+            Document: A List of Document objects.
+        """
+        return [self.spec]
+
+    def process_api_spec(self, spec: dict) -> dict:
+        """Perform simplification and reduction on an OpenAPI specification.
+
+        The goal is to create a more concise and efficient representation
+        for retrieval purposes.
+        """
+
+        def reduce_details(details: dict) -> dict:
+            reduced = {}
+            if details.get("description"):
+                reduced["description"] = details.get("description")
+            if details.get("parameters"):
+                reduced["parameters"] = [
+                    param
+                    for param in details.get("parameters", [])
+                    if param.get("required")
+                ]
+            if "200" in details["responses"]:
+                reduced["responses"] = details["responses"]["200"]
+            return reduced
+
+        def dereference_openapi(openapi_doc):
+            """Dereferences a Swagger/OpenAPI document by resolving all $ref pointers."""
+            try:
+                import jsonschema
+            except ImportError:
+                raise ImportError(
+                    "The jsonschema library is required to parse OpenAPI documents. "
+                    "Please install it with `pip install jsonschema`."
+                )
+
+            resolver = jsonschema.RefResolver.from_schema(openapi_doc)
+
+            def _dereference(obj):
+                if isinstance(obj, dict):
+                    if "$ref" in obj:
+                        with resolver.resolving(obj["$ref"]) as resolved:
+                            return _dereference(resolved)
+                    return {k: _dereference(v) for k, v in obj.items()}
+                elif isinstance(obj, list):
+                    return [_dereference(item) for item in obj]
+                else:
+                    return obj
+
+            dereferenced_doc = _dereference(openapi_doc)
+            return dereferenced_doc
+
+        spec = dereference_openapi(spec)
+        endpoints = []
+        for route, operations in spec["paths"].items():
+            for operation, details in operations.items():
+                if operation in ["get", "post", "patch"]:
+                    endpoint_name = f"{operation.upper()} {route}"
+                    description = details.get("description")
+                    endpoints.append(
+                        (endpoint_name, description, reduce_details(details))
+                    )
+
+        return {
+            "servers": spec["servers"],
+            "description": spec["info"].get("description"),
+            "endpoints": endpoints,
+        }

llama_index_tools_openapi-0.0.1.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: llama-index-tools-openapi
+Version: 0.0.1
+Summary: llama-index tools openapi integration
+License: MIT
+Author: Your Name
+Author-email: you@example.com
+Requires-Python: >=3.8.1,<3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: llama-index-core (>=0.9.32,<0.10.0)
+Description-Content-Type: text/markdown
+
+# OpenAPI Tool
+
+This tool loads an OpenAPI spec and allow the Agent to retrieve endpoints and details about endpoints. The RequestsToolSpec can also be laoded into the agent to allow the agent to hit the nessecary endpoints with a REST request.
+
+## Usage
+
+This tool has more extensive example usage documented in a Jupyter notebook [here](https://github.com/emptycrown/llama-hub/tree/main/llama_hub/tools/notebooks/openapi_and_requests.ipynb)
+
+Here's an example usage of the OpenAPIToolSpec.
+
+```python
+from llama_hub.tools.openapi import OpenAPIToolSpec
+from llama_index.agent import OpenAIAgent
+
+f = requests.get(
+    "https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/openai.com/1.2.0/openapi.yaml"
+).text
+open_api_spec = yaml.safe_load(f)
+# OR
+open_spec = OpenAPIToolSpec(
+    url="https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/openai.com/1.2.0/openapi.yaml"
+)
+
+
+tool_spec = OpenAPIToolSpec(open_api_spec)
+
+agent = OpenAIAgent.from_tools(tool_spec.to_tool_list())
+
+agent.chat("What is the base url for the API")
+agent.chat("What parameters does the x endpoint need?")
+```
+
+`load_openapi_spec`: Returns the parsed OpenAPI spec that the class was initialized with
+
+This loader is designed to be used as a way to load data as a Tool in a Agent. See [here](https://github.com/emptycrown/llama-hub/tree/main) for examples.
+

llama_index_tools_openapi-0.0.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+llama_index/tools/openapi/__init__.py,sha256=fh3NOSZQz1J1lr1R0XBAu_bxFkAS2bUcnOXlQJIw3D4,113
+llama_index/tools/openapi/base.py,sha256=QSBwHnWtVlNmjS4Hq4u49_pnECncBoH_RygzJRVQK44,4200
+llama_index_tools_openapi-0.0.1.dist-info/METADATA,sha256=q72LumcqUDtPtgLKPUlMQOPTsuAAT_fSSv4eZYKZtdg,1922
+llama_index_tools_openapi-0.0.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+llama_index_tools_openapi-0.0.1.dist-info/RECORD,,

llama_index_tools_openapi-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any