orbis-sdk 0.1.0__tar.gz

orbis_sdk-0.1.0/.gitignore

@@ -0,0 +1,49 @@
+# See https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files for more about ignoring files.
+
+# compiled output
+dist
+tmp
+out-tsc
+*.tsbuildinfo
+.expo
+.expo-shared
+
+# dependencies
+node_modules
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# misc
+/.sass-cache
+/connect.lock
+/coverage
+/libpeerconnection.log
+npm-debug.log
+yarn-error.log
+testem.log
+/typings
+
+# System Files
+.DS_Store
+Thumbs.db
+
+.cursor/rules/nx-rules.mdc
+.github/instructions/nx.instructions.md
+
+# Replit
+.cache/
+.local/

orbis_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: orbis-sdk
+Version: 0.1.0
+Summary: Python SDK for the Orbis API Marketplace — call any API, pay per use with USDC, native LangChain/CrewAI/AutoGen support.
+Project-URL: Homepage, https://orbisapi.com
+Project-URL: Documentation, https://orbisapi.com/docs
+Project-URL: Repository, https://github.com/orbisapi/orbis-sdk
+Project-URL: Bug Tracker, https://github.com/orbisapi/orbis-sdk/issues
+License: MIT
+Keywords: agents,api,autogen,crewai,langchain,marketplace,usdc,x402
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: requests>=2.31.0
+Provides-Extra: all
+Requires-Dist: crewai>=0.80.0; extra == 'all'
+Requires-Dist: langchain-core>=0.2.0; extra == 'all'
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.2.0; extra == 'autogen'
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80.0; extra == 'crewai'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2.0; extra == 'langchain'
+Description-Content-Type: text/markdown
+
+# orbis-sdk
+
+The official Python SDK for [Orbis API Marketplace](https://orbisapi.com) — the default execution and payment layer for agent workflows.
+
+Call any of 700+ production APIs from your AI agent with a single line. Native support for LangChain, CrewAI, and AutoGen.
+
+## Install
+
+```bash
+pip install orbis-sdk
+```
+
+With framework integrations:
+
+```bash
+pip install orbis-sdk[langchain]   # LangChain support
+pip install orbis-sdk[crewai]      # CrewAI support
+pip install orbis-sdk[all]         # Everything
+```
+
+## Quick Start
+
+Get your API key at [orbisapi.com](https://orbisapi.com).
+
+```python
+from orbis import OrbisClient
+
+client = OrbisClient(api_key="sk_...")
+
+# Search for APIs
+apis = client.search("tweet generator")
+for api in apis:
+    print(api.name, api.description)
+
+# Call an API
+result = client.call(
+    "tweet-thread-generator-api",
+    {"topic": "Why AI agents are replacing SaaS"}
+)
+
+if result.success:
+    print(result.data)
+```
+
+## LangChain
+
+```python
+from orbis import OrbisClient
+from langchain_openai import ChatOpenAI
+from langchain.agents import create_react_agent, AgentExecutor
+
+client = OrbisClient(api_key="sk_...")
+
+# Wrap Orbis APIs as LangChain tools
+tools = client.as_langchain_tools([
+    "tweet-thread-generator-api",
+    "credit-score-estimator",
+    "weather-api",
+])
+
+llm = ChatOpenAI(model="gpt-4o")
+agent = create_react_agent(llm, tools, prompt)
+executor = AgentExecutor(agent=agent, tools=tools)
+
+result = executor.invoke({"input": "Write a thread about AI agents"})
+```
+
+Or search and use dynamically:
+
+```python
+from orbis.integrations.langchain import orbis_toolkit
+
+tools = orbis_toolkit(client, query="social media content", limit=5)
+```
+
+## CrewAI
+
+```python
+from orbis import OrbisClient
+from crewai import Agent, Task, Crew
+
+client = OrbisClient(api_key="sk_...")
+tools = client.as_crewai_tools(["tweet-thread-generator-api"])
+
+writer = Agent(
+    role="Content Writer",
+    goal="Write viral Twitter threads about AI",
+    backstory="Expert in social media content strategy",
+    tools=tools,
+    verbose=True,
+)
+
+task = Task(
+    description="Write a 10-tweet thread about why AI agents are replacing traditional SaaS",
+    expected_output="A numbered Twitter thread ready to post",
+    agent=writer,
+)
+
+crew = Crew(agents=[writer], tasks=[task])
+result = crew.kickoff()
+print(result)
+```
+
+## AutoGen
+
+```python
+from orbis import OrbisClient
+from orbis.integrations.autogen import register_orbis_tools
+import autogen
+
+client = OrbisClient(api_key="sk_...")
+
+llm_config = {
+    "config_list": [{"model": "gpt-4o", "api_key": "YOUR_OPENAI_KEY"}],
+    "functions": client.as_autogen_functions(["tweet-thread-generator-api"]),
+}
+
+assistant = autogen.AssistantAgent("assistant", llm_config=llm_config)
+user_proxy = autogen.UserProxyAgent("user", human_input_mode="NEVER")
+
+register_orbis_tools(client, assistant, user_proxy, ["tweet-thread-generator-api"])
+
+user_proxy.initiate_chat(
+    assistant,
+    message="Write a thread about the agent economy"
+)
+```
+
+## Available APIs
+
+Browse all 700+ APIs at [orbisapi.com/marketplace](https://orbisapi.com/marketplace).
+
+Categories include:
+- AI & Machine Learning
+- Finance & Crypto
+- Social Media
+- Data & Analytics
+- Communication
+- Developer Tools
+
+## Pricing
+
+Pay per call. No subscriptions required. Prices set by API providers — Orbis takes 10%, providers keep 90%.
+
+Some APIs accept USDC payments via x402 on Base for fully autonomous agent payment flows.
+
+## Links
+
+- [Marketplace](https://orbisapi.com/marketplace)
+- [Docs](https://orbisapi.com/docs)
+- [Discord](https://discord.gg/orbisapi)
+- [Twitter](https://twitter.com/orbisapi)

orbis_sdk-0.1.0/README.md

@@ -0,0 +1,152 @@
+# orbis-sdk
+
+The official Python SDK for [Orbis API Marketplace](https://orbisapi.com) — the default execution and payment layer for agent workflows.
+
+Call any of 700+ production APIs from your AI agent with a single line. Native support for LangChain, CrewAI, and AutoGen.
+
+## Install
+
+```bash
+pip install orbis-sdk
+```
+
+With framework integrations:
+
+```bash
+pip install orbis-sdk[langchain]   # LangChain support
+pip install orbis-sdk[crewai]      # CrewAI support
+pip install orbis-sdk[all]         # Everything
+```
+
+## Quick Start
+
+Get your API key at [orbisapi.com](https://orbisapi.com).
+
+```python
+from orbis import OrbisClient
+
+client = OrbisClient(api_key="sk_...")
+
+# Search for APIs
+apis = client.search("tweet generator")
+for api in apis:
+    print(api.name, api.description)
+
+# Call an API
+result = client.call(
+    "tweet-thread-generator-api",
+    {"topic": "Why AI agents are replacing SaaS"}
+)
+
+if result.success:
+    print(result.data)
+```
+
+## LangChain
+
+```python
+from orbis import OrbisClient
+from langchain_openai import ChatOpenAI
+from langchain.agents import create_react_agent, AgentExecutor
+
+client = OrbisClient(api_key="sk_...")
+
+# Wrap Orbis APIs as LangChain tools
+tools = client.as_langchain_tools([
+    "tweet-thread-generator-api",
+    "credit-score-estimator",
+    "weather-api",
+])
+
+llm = ChatOpenAI(model="gpt-4o")
+agent = create_react_agent(llm, tools, prompt)
+executor = AgentExecutor(agent=agent, tools=tools)
+
+result = executor.invoke({"input": "Write a thread about AI agents"})
+```
+
+Or search and use dynamically:
+
+```python
+from orbis.integrations.langchain import orbis_toolkit
+
+tools = orbis_toolkit(client, query="social media content", limit=5)
+```
+
+## CrewAI
+
+```python
+from orbis import OrbisClient
+from crewai import Agent, Task, Crew
+
+client = OrbisClient(api_key="sk_...")
+tools = client.as_crewai_tools(["tweet-thread-generator-api"])
+
+writer = Agent(
+    role="Content Writer",
+    goal="Write viral Twitter threads about AI",
+    backstory="Expert in social media content strategy",
+    tools=tools,
+    verbose=True,
+)
+
+task = Task(
+    description="Write a 10-tweet thread about why AI agents are replacing traditional SaaS",
+    expected_output="A numbered Twitter thread ready to post",
+    agent=writer,
+)
+
+crew = Crew(agents=[writer], tasks=[task])
+result = crew.kickoff()
+print(result)
+```
+
+## AutoGen
+
+```python
+from orbis import OrbisClient
+from orbis.integrations.autogen import register_orbis_tools
+import autogen
+
+client = OrbisClient(api_key="sk_...")
+
+llm_config = {
+    "config_list": [{"model": "gpt-4o", "api_key": "YOUR_OPENAI_KEY"}],
+    "functions": client.as_autogen_functions(["tweet-thread-generator-api"]),
+}
+
+assistant = autogen.AssistantAgent("assistant", llm_config=llm_config)
+user_proxy = autogen.UserProxyAgent("user", human_input_mode="NEVER")
+
+register_orbis_tools(client, assistant, user_proxy, ["tweet-thread-generator-api"])
+
+user_proxy.initiate_chat(
+    assistant,
+    message="Write a thread about the agent economy"
+)
+```
+
+## Available APIs
+
+Browse all 700+ APIs at [orbisapi.com/marketplace](https://orbisapi.com/marketplace).
+
+Categories include:
+- AI & Machine Learning
+- Finance & Crypto
+- Social Media
+- Data & Analytics
+- Communication
+- Developer Tools
+
+## Pricing
+
+Pay per call. No subscriptions required. Prices set by API providers — Orbis takes 10%, providers keep 90%.
+
+Some APIs accept USDC payments via x402 on Base for fully autonomous agent payment flows.
+
+## Links
+
+- [Marketplace](https://orbisapi.com/marketplace)
+- [Docs](https://orbisapi.com/docs)
+- [Discord](https://discord.gg/orbisapi)
+- [Twitter](https://twitter.com/orbisapi)

orbis_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "orbis-sdk"
+version = "0.1.0"
+description = "Python SDK for the Orbis API Marketplace — call any API, pay per use with USDC, native LangChain/CrewAI/AutoGen support."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["api", "marketplace", "agents", "langchain", "crewai", "autogen", "usdc", "x402"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "requests>=2.31.0",
+    "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+langchain = ["langchain-core>=0.2.0"]
+crewai = ["crewai>=0.80.0"]
+autogen = ["pyautogen>=0.2.0"]
+all = ["langchain-core>=0.2.0", "crewai>=0.80.0"]
+
+[project.urls]
+Homepage = "https://orbisapi.com"
+Documentation = "https://orbisapi.com/docs"
+Repository = "https://github.com/orbisapi/orbis-sdk"
+"Bug Tracker" = "https://github.com/orbisapi/orbis-sdk/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/orbis"]

orbis_sdk-0.1.0/src/orbis/__init__.py

@@ -0,0 +1,18 @@
+"""
+Orbis SDK — Python client for the Orbis API Marketplace.
+
+The default execution and payment layer for agent workflows.
+
+Quick start:
+    from orbis import OrbisClient
+
+    client = OrbisClient(api_key="sk_...")
+    result = client.call("tweet-thread-generator-api", {"topic": "AI agents"})
+    print(result)
+"""
+
+from orbis.client import OrbisClient
+from orbis.models import APIListing, CallResult
+
+__version__ = "0.1.0"
+__all__ = ["OrbisClient", "APIListing", "CallResult"]

orbis_sdk-0.1.0/src/orbis/client.py

@@ -0,0 +1,209 @@
+"""
+Core HTTP client for the Orbis API Marketplace.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+from urllib.parse import urljoin
+
+import requests
+
+from orbis.models import APIListing, CallResult
+
+BASE_URL = "https://orbisapi.com"
+
+
+class OrbisClient:
+    """
+    Client for calling APIs on the Orbis marketplace.
+
+    Args:
+        api_key: Your Orbis API key (sk_...). Get one at orbisapi.com
+        base_url: Override the API base URL (useful for testing).
+        timeout: Request timeout in seconds. Default 30.
+
+    Example:
+        client = OrbisClient(api_key="sk_...")
+        result = client.call("tweet-thread-generator-api", {"topic": "AI agents"})
+        print(result.data)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = BASE_URL,
+        timeout: int = 30,
+    ):
+        if not api_key or not api_key.startswith("sk_"):
+            raise ValueError("Invalid API key. Get yours at orbisapi.com")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({
+            "x-api-key": self.api_key,
+            "Content-Type": "application/json",
+            "User-Agent": "orbis-sdk-python/0.1.0",
+        })
+
+    def search(self, query: str, limit: int = 10) -> list[APIListing]:
+        """
+        Search for APIs on Orbis.
+
+        Args:
+            query: Search query (e.g. "weather", "tweet generator")
+            limit: Max number of results to return.
+
+        Returns:
+            List of APIListing objects.
+        """
+        resp = self._session.get(
+            f"{self.base_url}/api/agents/discovery",
+            params={"q": query, "limit": limit},
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        apis = data if isinstance(data, list) else data.get("apis", [])
+        return [APIListing.from_dict(a) for a in apis[:limit]]
+
+    def list_apis(self, category: Optional[str] = None, limit: int = 50) -> list[APIListing]:
+        """
+        List available APIs on Orbis.
+
+        Args:
+            category: Filter by category (optional).
+            limit: Max results.
+
+        Returns:
+            List of APIListing objects.
+        """
+        params: dict[str, Any] = {"limit": limit}
+        if category:
+            params["category"] = category
+        resp = self._session.get(
+            f"{self.base_url}/api/agents/discovery",
+            params=params,
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        apis = data if isinstance(data, list) else data.get("apis", [])
+        return [APIListing.from_dict(a) for a in apis]
+
+    def call(
+        self,
+        api_slug: str,
+        payload: dict[str, Any],
+        endpoint: str = "/",
+        method: str = "POST",
+    ) -> CallResult:
+        """
+        Call an API on the Orbis marketplace.
+
+        Args:
+            api_slug: The API slug (e.g. "tweet-thread-generator-api")
+            payload: Request body as a dict.
+            endpoint: API sub-path to call (default "/").
+            method: HTTP method (default "POST").
+
+        Returns:
+            CallResult with success status and response data.
+
+        Example:
+            result = client.call(
+                "tweet-thread-generator-api",
+                {"topic": "AI agents replacing SaaS"},
+            )
+            if result.success:
+                print(result.data)
+        """
+        url = f"{self.base_url}/api/proxy/{api_slug}{endpoint}"
+        try:
+            resp = self._session.request(
+                method=method.upper(),
+                url=url,
+                json=payload if method.upper() != "GET" else None,
+                params=payload if method.upper() == "GET" else None,
+                timeout=self.timeout,
+            )
+            try:
+                data = resp.json()
+            except Exception:
+                data = resp.text
+
+            return CallResult(
+                success=resp.ok,
+                data=data,
+                status_code=resp.status_code,
+                api_slug=api_slug,
+                endpoint=endpoint,
+                error=None if resp.ok else str(data),
+            )
+        except requests.RequestException as e:
+            return CallResult(
+                success=False,
+                data=None,
+                status_code=0,
+                api_slug=api_slug,
+                endpoint=endpoint,
+                error=str(e),
+            )
+
+    def get_api(self, slug: str) -> Optional[APIListing]:
+        """Fetch a single API listing by slug."""
+        try:
+            resp = self._session.get(
+                f"{self.base_url}/api/agents/discovery",
+                params={"slug": slug},
+                timeout=self.timeout,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            apis = data if isinstance(data, list) else data.get("apis", [])
+            if apis:
+                return APIListing.from_dict(apis[0])
+        except Exception:
+            pass
+        return None
+
+    def as_langchain_tools(self, api_slugs: list[str]) -> list:
+        """
+        Convert a list of API slugs into LangChain BaseTool instances.
+
+        Requires: pip install orbis-sdk[langchain]
+
+        Example:
+            tools = client.as_langchain_tools(["tweet-thread-generator-api"])
+            agent = create_react_agent(llm, tools)
+        """
+        from orbis.integrations.langchain import OrbisAPITool
+        return [OrbisAPITool(client=self, api_slug=slug) for slug in api_slugs]
+
+    def as_crewai_tools(self, api_slugs: list[str]) -> list:
+        """
+        Convert a list of API slugs into CrewAI BaseTool instances.
+
+        Requires: pip install orbis-sdk[crewai]
+
+        Example:
+            tools = client.as_crewai_tools(["tweet-thread-generator-api"])
+            agent = Agent(role="Writer", tools=tools)
+        """
+        from orbis.integrations.crewai import OrbisCrewAITool
+        return [OrbisCrewAITool(client=self, api_slug=slug) for slug in api_slugs]
+
+    def as_autogen_functions(self, api_slugs: list[str]) -> list[dict]:
+        """
+        Return AutoGen-compatible function definitions for a list of API slugs.
+
+        Requires: pip install pyautogen
+
+        Example:
+            functions = client.as_autogen_functions(["tweet-thread-generator-api"])
+            assistant = AssistantAgent("assistant", llm_config={"functions": functions})
+        """
+        from orbis.integrations.autogen import build_autogen_function
+        return [build_autogen_function(self, slug) for slug in api_slugs]

orbis_sdk-0.1.0/src/orbis/integrations/__init__.py

@@ -0,0 +1,7 @@
+"""
+Framework integrations for Orbis SDK.
+
+- LangChain: from orbis.integrations.langchain import OrbisAPITool
+- CrewAI:    from orbis.integrations.crewai import OrbisCrewAITool
+- AutoGen:   from orbis.integrations.autogen import build_autogen_function
+"""

orbis_sdk-0.1.0/src/orbis/integrations/autogen.py

@@ -0,0 +1,132 @@
+"""
+AutoGen integration for Orbis SDK.
+
+Requires: pip install pyautogen
+
+Usage:
+    from orbis import OrbisClient
+    from orbis.integrations.autogen import build_autogen_function, register_orbis_tools
+    import autogen
+
+    client = OrbisClient(api_key="sk_...")
+
+    llm_config = {
+        "config_list": [{"model": "gpt-4o", "api_key": "..."}],
+        "functions": client.as_autogen_functions(["tweet-thread-generator-api"]),
+    }
+
+    assistant = autogen.AssistantAgent("assistant", llm_config=llm_config)
+    user = autogen.UserProxyAgent("user", human_input_mode="NEVER")
+
+    # Register execution callbacks
+    register_orbis_tools(client, user, assistant, ["tweet-thread-generator-api"])
+
+    user.initiate_chat(assistant, message="Write a thread about AI agents")
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from orbis.client import OrbisClient
+
+
+def build_autogen_function(client: "OrbisClient", api_slug: str) -> dict:
+    """
+    Build an AutoGen-compatible function definition for an Orbis API.
+
+    Returns a dict with 'name', 'description', and 'parameters' fields
+    that can be passed to an AssistantAgent's llm_config['functions'].
+
+    Args:
+        client: OrbisClient instance.
+        api_slug: The API slug to wrap.
+
+    Returns:
+        AutoGen function definition dict.
+    """
+    listing = client.get_api(api_slug)
+    func_name = f"call_{api_slug.replace('-', '_')}"
+    description = (
+        f"Call the '{listing.name}' API via Orbis. {listing.description}"
+        if listing
+        else f"Call the '{api_slug}' API via Orbis marketplace."
+    )
+
+    return {
+        "name": func_name,
+        "description": description,
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "payload": {
+                    "type": "string",
+                    "description": "JSON string of the request parameters to send to the API.",
+                },
+                "endpoint": {
+                    "type": "string",
+                    "description": "API sub-path to call (default '/').",
+                    "default": "/",
+                },
+            },
+            "required": ["payload"],
+        },
+    }
+
+
+def _make_executor(client: "OrbisClient", api_slug: str) -> Callable:
+    """Create the execution function for a given API slug."""
+    def execute(payload: str, endpoint: str = "/") -> str:
+        try:
+            parsed = json.loads(payload)
+        except json.JSONDecodeError:
+            parsed = {"input": payload}
+        result = client.call(api_slug, parsed, endpoint=endpoint)
+        if result.success:
+            return json.dumps(result.data, ensure_ascii=False)
+        return f"Error calling {api_slug}: {result.error}"
+    execute.__name__ = f"call_{api_slug.replace('-', '_')}"
+    return execute
+
+
+def register_orbis_tools(
+    client: "OrbisClient",
+    caller: Any,
+    executor: Any,
+    api_slugs: list[str],
+) -> None:
+    """
+    Register Orbis API tools with an AutoGen agent pair.
+
+    Call this after creating your AssistantAgent and UserProxyAgent to
+    wire up the execution callbacks.
+
+    Args:
+        client: OrbisClient instance.
+        caller: The AssistantAgent that will call the functions.
+        executor: The UserProxyAgent that will execute them.
+        api_slugs: List of API slugs to register.
+
+    Example:
+        register_orbis_tools(client, assistant, user_proxy, ["tweet-thread-generator-api"])
+    """
+    try:
+        from autogen import register_function
+    except ImportError as e:
+        raise ImportError(
+            "pyautogen is required for AutoGen integration. "
+            "Install it with: pip install pyautogen"
+        ) from e
+
+    for slug in api_slugs:
+        func_def = build_autogen_function(client, slug)
+        fn = _make_executor(client, slug)
+        register_function(
+            fn,
+            caller=caller,
+            executor=executor,
+            name=func_def["name"],
+            description=func_def["description"],
+        )

orbis_sdk-0.1.0/src/orbis/integrations/crewai.py

@@ -0,0 +1,101 @@
+"""
+CrewAI integration for Orbis SDK.
+
+Requires: pip install orbis-sdk[crewai]
+
+Usage:
+    from orbis import OrbisClient
+    from crewai import Agent, Task, Crew
+
+    client = OrbisClient(api_key="sk_...")
+    tools = client.as_crewai_tools(["tweet-thread-generator-api"])
+
+    writer = Agent(
+        role="Content Writer",
+        goal="Write viral Twitter threads",
+        backstory="Expert in social media content",
+        tools=tools,
+    )
+
+    task = Task(
+        description="Write a thread about AI agents replacing SaaS",
+        agent=writer,
+    )
+
+    crew = Crew(agents=[writer], tasks=[task])
+    result = crew.kickoff()
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+if TYPE_CHECKING:
+    from orbis.client import OrbisClient
+
+try:
+    from crewai.tools import BaseTool
+    from pydantic import BaseModel, Field
+except ImportError as e:
+    raise ImportError(
+        "crewai is required for CrewAI integration. "
+        "Install it with: pip install orbis-sdk[crewai]"
+    ) from e
+
+
+class OrbisToolInput(BaseModel):
+    payload: str = Field(
+        description="JSON string of parameters to send to the API."
+    )
+    endpoint: str = Field(
+        default="/",
+        description="API sub-path to call (default '/').",
+    )
+
+
+class OrbisCrewAITool(BaseTool):
+    """
+    A CrewAI tool that wraps a specific API on the Orbis marketplace.
+
+    Each tool instance wraps one API slug. Pass multiple tools to an Agent
+    to give it access to multiple APIs.
+    """
+
+    name: str = "orbis_api"
+    description: str = "Call an API on the Orbis marketplace."
+    args_schema: Type[BaseModel] = OrbisToolInput
+    client: Any
+    api_slug: str
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, client: "OrbisClient", api_slug: str, **kwargs):
+        listing = client.get_api(api_slug)
+        tool_name = f"orbis_{api_slug.replace('-', '_')}"
+        tool_desc = (
+            f"Call the '{listing.name}' API via Orbis. {listing.description} "
+            f"Pass a JSON string as 'payload' with the required parameters."
+            if listing
+            else f"Call the '{api_slug}' API via Orbis. "
+                 f"Pass a JSON string as 'payload' with the required parameters."
+        )
+        super().__init__(
+            name=tool_name,
+            description=tool_desc,
+            client=client,
+            api_slug=api_slug,
+            **kwargs,
+        )
+
+    def _run(self, payload: str, endpoint: str = "/") -> str:
+        try:
+            parsed = json.loads(payload)
+        except json.JSONDecodeError:
+            parsed = {"input": payload}
+
+        result = self.client.call(self.api_slug, parsed, endpoint=endpoint)
+        if result.success:
+            return json.dumps(result.data, ensure_ascii=False)
+        return f"Error calling {self.api_slug}: {result.error}"

orbis_sdk-0.1.0/src/orbis/integrations/langchain.py

@@ -0,0 +1,123 @@
+"""
+LangChain integration for Orbis SDK.
+
+Requires: pip install orbis-sdk[langchain]
+
+Usage:
+    from orbis import OrbisClient
+    from orbis.integrations.langchain import OrbisAPITool, orbis_toolkit
+
+    client = OrbisClient(api_key="sk_...")
+
+    # Option 1: Specific APIs as tools
+    tools = client.as_langchain_tools([
+        "tweet-thread-generator-api",
+        "credit-score-estimator",
+    ])
+
+    # Option 2: Build a full toolkit from search
+    tools = orbis_toolkit(client, query="social media", limit=5)
+
+    # Use with any LangChain agent
+    from langchain.agents import create_react_agent
+    agent = create_react_agent(llm, tools, prompt)
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+if TYPE_CHECKING:
+    from orbis.client import OrbisClient
+
+try:
+    from langchain_core.tools import BaseTool
+    from pydantic import BaseModel, Field
+except ImportError as e:
+    raise ImportError(
+        "langchain-core is required for LangChain integration. "
+        "Install it with: pip install orbis-sdk[langchain]"
+    ) from e
+
+
+class OrbisCallInput(BaseModel):
+    payload: str = Field(
+        description="JSON string of the request payload to send to the API."
+    )
+    endpoint: str = Field(
+        default="/",
+        description="API endpoint path to call (default '/').",
+    )
+
+
+class OrbisAPITool(BaseTool):
+    """
+    A LangChain tool that calls a specific API on the Orbis marketplace.
+
+    Each tool wraps a single API. Use OrbisClient.as_langchain_tools() to
+    generate a list of tools for multiple APIs at once.
+    """
+
+    name: str = "orbis_api"
+    description: str = "Call an API on the Orbis marketplace."
+    args_schema: Type[BaseModel] = OrbisCallInput
+    client: Any
+    api_slug: str
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, client: "OrbisClient", api_slug: str, **kwargs):
+        listing = client.get_api(api_slug)
+        tool_name = f"orbis_{api_slug.replace('-', '_')}"
+        tool_desc = (
+            f"Call the '{listing.name}' API via Orbis. {listing.description}"
+            if listing
+            else f"Call the '{api_slug}' API via Orbis."
+        )
+        super().__init__(
+            name=tool_name,
+            description=tool_desc,
+            client=client,
+            api_slug=api_slug,
+            **kwargs,
+        )
+
+    def _run(self, payload: str, endpoint: str = "/") -> str:
+        try:
+            parsed = json.loads(payload)
+        except json.JSONDecodeError:
+            parsed = {"input": payload}
+
+        result = self.client.call(self.api_slug, parsed, endpoint=endpoint)
+        if result.success:
+            return json.dumps(result.data, ensure_ascii=False)
+        return f"Error calling {self.api_slug}: {result.error}"
+
+    async def _arun(self, payload: str, endpoint: str = "/") -> str:
+        return self._run(payload, endpoint)
+
+
+def orbis_toolkit(
+    client: "OrbisClient",
+    query: str,
+    limit: int = 5,
+) -> list[OrbisAPITool]:
+    """
+    Search Orbis and return matching APIs as LangChain tools.
+
+    Args:
+        client: OrbisClient instance.
+        query: What kind of APIs to search for.
+        limit: Max tools to return.
+
+    Returns:
+        List of OrbisAPITool instances ready to pass to an agent.
+
+    Example:
+        tools = orbis_toolkit(client, query="data enrichment", limit=3)
+        agent = create_react_agent(llm, tools, prompt)
+    """
+    listings = client.search(query, limit=limit)
+    return [OrbisAPITool(client=client, api_slug=l.slug) for l in listings]

orbis_sdk-0.1.0/src/orbis/models.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+@dataclass
+class APIListing:
+    id: str
+    name: str
+    slug: str
+    description: str
+    category: str
+    base_url: str
+    tiers: list[dict] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "APIListing":
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            slug=data.get("slug", ""),
+            description=data.get("description", ""),
+            category=data.get("category", ""),
+            base_url=data.get("baseUrl", ""),
+            tiers=data.get("tiers", []),
+            tags=data.get("tags", []),
+        )
+
+
+@dataclass
+class CallResult:
+    success: bool
+    data: Any
+    status_code: int
+    api_slug: str
+    endpoint: str
+    error: Optional[str] = None
+
+    def __repr__(self) -> str:
+        if self.success:
+            return f"<CallResult {self.api_slug} OK>"
+        return f"<CallResult {self.api_slug} ERROR: {self.error}>"