langchain-pythia 0.1.0__tar.gz

langchain_pythia-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/

langchain_pythia-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pythia Oracle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_pythia-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: langchain-pythia
+Version: 0.1.0
+Summary: LangChain integration for Pythia Oracle — on-chain calculated crypto indicators (EMA, RSI, Bollinger, Volatility) via Chainlink
+Project-URL: Homepage, https://pythia.c3x-solutions.com
+Project-URL: Repository, https://github.com/pythia-the-oracle/langchain-pythia
+Project-URL: Documentation, https://github.com/pythia-the-oracle/langchain-pythia#readme
+Author-email: Pythia Oracle <ivan.jeremic@c3x-solutions.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agent,bollinger,chainlink,crypto,defi,ema,langchain,on-chain,oracle,rsi,smart-contracts,technical-analysis,volatility
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0.0,>=0.25.0
+Requires-Dist: langchain-core<2.0.0,>=1.2.21
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.20; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# langchain-pythia
+
+[![PyPI](https://img.shields.io/pypi/v/langchain-pythia)](https://pypi.org/project/langchain-pythia/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**LangChain integration for Pythia Oracle — on-chain calculated crypto indicators via Chainlink.**
+
+Access EMA, RSI, Bollinger Bands, Volatility, and more for 22 crypto tokens directly from your LangChain agents. Pythia is the first oracle delivering calculated technical indicators on-chain, not just prices.
+
+## Installation
+
+```bash
+pip install langchain-pythia
+```
+
+## Quick Start
+
+```python
+from langchain_pythia import PythiaListTokensTool, PythiaTokenFeedsTool
+
+# Use with any LangChain agent
+tools = [PythiaListTokensTool(), PythiaTokenFeedsTool()]
+
+# Or call directly
+list_tool = PythiaListTokensTool()
+print(list_tool.invoke(""))
+
+feeds_tool = PythiaTokenFeedsTool()
+print(feeds_tool.invoke({"engine_id": "bitcoin"}))
+```
+
+## With a LangChain Agent
+
+```python
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+from langchain_pythia import (
+    PythiaListTokensTool,
+    PythiaTokenFeedsTool,
+    PythiaHealthCheckTool,
+    PythiaContractsTool,
+    PythiaPricingTool,
+)
+
+tools = [
+    PythiaListTokensTool(),
+    PythiaTokenFeedsTool(),
+    PythiaHealthCheckTool(),
+    PythiaContractsTool(),
+    PythiaPricingTool(),
+]
+
+llm = ChatOpenAI(model="gpt-4o")
+agent = create_react_agent(llm, tools)
+
+# Ask about on-chain indicators
+response = agent.invoke(
+    {"messages": [{"role": "user", "content": "What RSI feeds does Pythia have for Bitcoin?"}]}
+)
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `PythiaListTokensTool` | List all 22 tracked tokens with status, uptime, and data sources |
+| `PythiaTokenFeedsTool` | Get all indicator feed names (EMA, RSI, Bollinger, Volatility) for a token |
+| `PythiaHealthCheckTool` | Per-token 30-day uptime, data source health, incident report |
+| `PythiaContractsTool` | Contract addresses (operator, consumers, faucet, LINK) for on-chain integration |
+| `PythiaPricingTool` | Pricing tiers and free trial faucet info |
+
+## What Pythia Provides
+
+- **484 indicator feeds** across 22 tokens (BTC, SOL, TAO, RENDER, ONDO, AAVE, UNI, and more)
+- **5 indicator types:** EMA, RSI, Bollinger (upper/lower), Volatility, USD Price
+- **4 timeframes:** 5-minute, 1-hour, 1-day, 1-week
+- **On-chain delivery** via Chainlink on Polygon
+- **Free trial** via PythiaFaucet — no LINK needed, 5 requests/day
+
+## Use Cases
+
+- **AI trading agents** that need on-chain technical signals
+- **DeFi vault rebalancing** based on RSI or volatility thresholds
+- **Risk management** using Bollinger Band width
+- **Portfolio analysis** with real-time calculated metrics
+
+## Related
+
+- [Pythia MCP Server](https://pypi.org/project/pythia-oracle-mcp/) — MCP integration for Claude, Cursor, VS Code
+- [Integration Examples](https://github.com/pythia-the-oracle/pythia-oracle-examples) — Solidity contracts with Hardhat
+- [Website & Feed Explorer](https://pythia.c3x-solutions.com)
+
+## License
+
+MIT

langchain_pythia-0.1.0/README.md

@@ -0,0 +1,95 @@
+# langchain-pythia
+
+[![PyPI](https://img.shields.io/pypi/v/langchain-pythia)](https://pypi.org/project/langchain-pythia/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**LangChain integration for Pythia Oracle — on-chain calculated crypto indicators via Chainlink.**
+
+Access EMA, RSI, Bollinger Bands, Volatility, and more for 22 crypto tokens directly from your LangChain agents. Pythia is the first oracle delivering calculated technical indicators on-chain, not just prices.
+
+## Installation
+
+```bash
+pip install langchain-pythia
+```
+
+## Quick Start
+
+```python
+from langchain_pythia import PythiaListTokensTool, PythiaTokenFeedsTool
+
+# Use with any LangChain agent
+tools = [PythiaListTokensTool(), PythiaTokenFeedsTool()]
+
+# Or call directly
+list_tool = PythiaListTokensTool()
+print(list_tool.invoke(""))
+
+feeds_tool = PythiaTokenFeedsTool()
+print(feeds_tool.invoke({"engine_id": "bitcoin"}))
+```
+
+## With a LangChain Agent
+
+```python
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+from langchain_pythia import (
+    PythiaListTokensTool,
+    PythiaTokenFeedsTool,
+    PythiaHealthCheckTool,
+    PythiaContractsTool,
+    PythiaPricingTool,
+)
+
+tools = [
+    PythiaListTokensTool(),
+    PythiaTokenFeedsTool(),
+    PythiaHealthCheckTool(),
+    PythiaContractsTool(),
+    PythiaPricingTool(),
+]
+
+llm = ChatOpenAI(model="gpt-4o")
+agent = create_react_agent(llm, tools)
+
+# Ask about on-chain indicators
+response = agent.invoke(
+    {"messages": [{"role": "user", "content": "What RSI feeds does Pythia have for Bitcoin?"}]}
+)
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `PythiaListTokensTool` | List all 22 tracked tokens with status, uptime, and data sources |
+| `PythiaTokenFeedsTool` | Get all indicator feed names (EMA, RSI, Bollinger, Volatility) for a token |
+| `PythiaHealthCheckTool` | Per-token 30-day uptime, data source health, incident report |
+| `PythiaContractsTool` | Contract addresses (operator, consumers, faucet, LINK) for on-chain integration |
+| `PythiaPricingTool` | Pricing tiers and free trial faucet info |
+
+## What Pythia Provides
+
+- **484 indicator feeds** across 22 tokens (BTC, SOL, TAO, RENDER, ONDO, AAVE, UNI, and more)
+- **5 indicator types:** EMA, RSI, Bollinger (upper/lower), Volatility, USD Price
+- **4 timeframes:** 5-minute, 1-hour, 1-day, 1-week
+- **On-chain delivery** via Chainlink on Polygon
+- **Free trial** via PythiaFaucet — no LINK needed, 5 requests/day
+
+## Use Cases
+
+- **AI trading agents** that need on-chain technical signals
+- **DeFi vault rebalancing** based on RSI or volatility thresholds
+- **Risk management** using Bollinger Band width
+- **Portfolio analysis** with real-time calculated metrics
+
+## Related
+
+- [Pythia MCP Server](https://pypi.org/project/pythia-oracle-mcp/) — MCP integration for Claude, Cursor, VS Code
+- [Integration Examples](https://github.com/pythia-the-oracle/pythia-oracle-examples) — Solidity contracts with Hardhat
+- [Website & Feed Explorer](https://pythia.c3x-solutions.com)
+
+## License
+
+MIT

langchain_pythia-0.1.0/langchain_pythia/__init__.py

@@ -0,0 +1,17 @@
+"""LangChain integration for Pythia Oracle — on-chain calculated crypto indicators."""
+
+from langchain_pythia.tools import (
+    PythiaListTokensTool,
+    PythiaTokenFeedsTool,
+    PythiaHealthCheckTool,
+    PythiaContractsTool,
+    PythiaPricingTool,
+)
+
+__all__ = [
+    "PythiaListTokensTool",
+    "PythiaTokenFeedsTool",
+    "PythiaHealthCheckTool",
+    "PythiaContractsTool",
+    "PythiaPricingTool",
+]

langchain_pythia-0.1.0/langchain_pythia/_client.py

@@ -0,0 +1,42 @@
+"""Internal HTTP client for fetching Pythia Oracle data."""
+
+from datetime import datetime, timezone
+
+import httpx
+
+DATA_URL = "https://pythia.c3x-solutions.com/feed-status.json"
+CACHE_TTL_SECONDS = 60
+
+_cache: dict = {}
+
+
+async def fetch_data() -> dict:
+    """Fetch feed-status.json with 60s cache."""
+    now = datetime.now(timezone.utc)
+    cached = _cache.get("data")
+    if cached and (now - cached["at"]).total_seconds() < CACHE_TTL_SECONDS:
+        return cached["data"]
+
+    async with httpx.AsyncClient(timeout=15) as client:
+        resp = await client.get(DATA_URL)
+        resp.raise_for_status()
+        data = resp.json()
+
+    _cache["data"] = {"data": data, "at": now}
+    return data
+
+
+def fetch_data_sync() -> dict:
+    """Synchronous version of fetch_data."""
+    now = datetime.now(timezone.utc)
+    cached = _cache.get("data")
+    if cached and (now - cached["at"]).total_seconds() < CACHE_TTL_SECONDS:
+        return cached["data"]
+
+    with httpx.Client(timeout=15) as client:
+        resp = client.get(DATA_URL)
+        resp.raise_for_status()
+        data = resp.json()
+
+    _cache["data"] = {"data": data, "at": now}
+    return data

langchain_pythia-0.1.0/langchain_pythia/tools.py

@@ -0,0 +1,317 @@
+"""Pythia Oracle tools for LangChain.
+
+Provides access to on-chain calculated crypto indicators (EMA, RSI,
+Bollinger Bands, Volatility) for 22 tokens via Chainlink on Polygon.
+"""
+
+import json
+from typing import Optional, Type
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from langchain_pythia._client import fetch_data, fetch_data_sync
+
+# ---------------------------------------------------------------------------
+# Contracts (static, rarely changes)
+# ---------------------------------------------------------------------------
+
+CONTRACTS = {
+    "chain": "Polygon",
+    "chain_id": 137,
+    "link_token_erc677": "0xb0897686c545045aFc77CF20eC7A532E3120E0F1",
+    "operator": "0xAA37710aF244514691629Aa15f4A5c271EaE6891",
+    "faucet": "0x640fC3B9B607E324D7A3d89Fcb62C77Cc0Bd420A",
+    "consumers": {
+        "discovery": {
+            "address": "0xeC2865d66ae6Af47926B02edd942A756b394F820",
+            "fee": "0.01 LINK",
+            "returns": "uint256 (single indicator)",
+        },
+        "analysis": {
+            "address": "0x3b3aC62d73E537E3EF84D97aB5B84B51aF8dB316",
+            "fee": "0.03 LINK",
+            "returns": "uint256[] (1H/1D/1W bundle)",
+        },
+        "speed": {
+            "address": "0xC406e7d9AC385e7AB43cBD56C74ad487f085d47B",
+            "fee": "0.05 LINK",
+            "returns": "uint256[] (5M bundle)",
+        },
+        "complete": {
+            "address": "0x2dEC98fd7173802b351d1E28d0Cd5DdD20C24252",
+            "fee": "0.10 LINK",
+            "returns": "uint256[] (all indicators)",
+        },
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# Tool: List Tokens
+# ---------------------------------------------------------------------------
+
+
+class PythiaListTokensTool(BaseTool):
+    """List all tokens tracked by Pythia Oracle with status and reliability.
+
+    Returns token symbols, categories, data source count, 30-day uptime,
+    and operational status. Covers cross-chain tokens (BTC, SOL, TAO,
+    RENDER, ONDO, etc.) and Polygon DeFi tokens.
+    """
+
+    name: str = "pythia_list_tokens"
+    description: str = (
+        "List all crypto tokens tracked by Pythia Oracle with their status, "
+        "30-day uptime, and data source count. Covers 22 tokens including "
+        "BTC, SOL, TAO, RENDER, ONDO, AAVE, UNI, and more."
+    )
+
+    def _run(
+        self, run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> str:
+        data = fetch_data_sync()
+        return _format_token_list(data)
+
+    async def _arun(
+        self, run_manager: Optional[AsyncCallbackManagerForToolRun] = None
+    ) -> str:
+        data = await fetch_data()
+        return _format_token_list(data)
+
+
+def _format_token_list(data: dict) -> str:
+    tokens = data.get("tokens", [])
+    stats = data.get("stats", {})
+    lines = [
+        f"Pythia Oracle — {stats.get('tokens', len(tokens))} tokens, "
+        f"{stats.get('total_indicators', '?')} indicator feeds\n"
+    ]
+    lines.append(
+        f"{'Symbol':<8} {'Engine ID':<28} {'Category':<16} "
+        f"{'Status':<6} {'Uptime':>7}  {'Src':>3}"
+    )
+    lines.append("-" * 78)
+    for t in sorted(tokens, key=lambda x: x.get("category", "")):
+        uptime = (
+            f"{t['uptime_30d']:.1f}%"
+            if t.get("uptime_30d") is not None
+            else "?"
+        )
+        lines.append(
+            f"{t['symbol']:<8} {t['engine_id']:<28} "
+            f"{t.get('category', '?'):<16} {t.get('status', '?'):<6} "
+            f"{uptime:>7}  {t.get('sources', '?'):>3}"
+        )
+    lines.append(f"\nWebsite: https://pythia.c3x-solutions.com")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Tool: Token Feeds
+# ---------------------------------------------------------------------------
+
+
+class _TokenFeedsInput(BaseModel):
+    engine_id: str = Field(
+        description=(
+            "Token engine ID, e.g. 'bitcoin', 'solana', 'bittensor', "
+            "'aave', 'render-token'. Use pythia_list_tokens to see all IDs."
+        )
+    )
+
+
+class PythiaTokenFeedsTool(BaseTool):
+    """Get all indicator feed names for a specific token.
+
+    Shows every available feed (EMA, RSI, Bollinger, Volatility across
+    all timeframes) plus the token's reliability stats.
+    """
+
+    name: str = "pythia_token_feeds"
+    description: str = (
+        "Get all available on-chain indicator feeds (EMA, RSI, Bollinger, "
+        "Volatility) for a specific crypto token from Pythia Oracle. "
+        "Returns feed names that can be used in smart contract calls."
+    )
+    args_schema: Type[BaseModel] = _TokenFeedsInput
+
+    def _run(
+        self,
+        engine_id: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        data = fetch_data_sync()
+        return _format_token_feeds(data, engine_id)
+
+    async def _arun(
+        self,
+        engine_id: str,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        data = await fetch_data()
+        return _format_token_feeds(data, engine_id)
+
+
+def _format_token_feeds(data: dict, engine_id: str) -> str:
+    tokens = data.get("tokens", [])
+    token = next((t for t in tokens if t["engine_id"] == engine_id), None)
+    if not token:
+        available = sorted(t["engine_id"] for t in tokens)
+        return f"No token found for '{engine_id}'.\nAvailable: {', '.join(available)}"
+
+    feed_names = token.get("feed_names", [])
+    lines = [
+        f"{token['symbol']} ({token['name']}) — {token.get('pair', '?')}",
+        f"Status: {token.get('status', '?')}  |  "
+        f"30d uptime: {token.get('uptime_30d', '?')}%  |  "
+        f"Data sources: {token.get('sources', '?')}",
+        f"\n{len(feed_names)} indicator feeds:\n",
+    ]
+    groups: dict[str, list[str]] = {}
+    for name in sorted(feed_names):
+        suffix = name[len(engine_id) + 1 :]
+        cat = suffix.split("_")[0]
+        groups.setdefault(cat, []).append(name)
+    for cat, feeds in sorted(groups.items()):
+        lines.append(f"  {cat}:")
+        for feed in feeds:
+            lines.append(f"    {feed}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Tool: Health Check
+# ---------------------------------------------------------------------------
+
+
+class PythiaHealthCheckTool(BaseTool):
+    """Check Pythia Oracle reliability and uptime.
+
+    Returns per-token 30-day uptime (worst-first), data source health,
+    infrastructure status, and active incidents.
+    """
+
+    name: str = "pythia_health_check"
+    description: str = (
+        "Check the reliability and uptime of Pythia Oracle. Returns "
+        "per-token 30-day uptime, data source health, infrastructure "
+        "status, and active incidents. Use before integrating."
+    )
+
+    def _run(
+        self, run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> str:
+        data = fetch_data_sync()
+        return _format_health(data)
+
+    async def _arun(
+        self, run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        data = await fetch_data()
+        return _format_health(data)
+
+
+def _format_health(data: dict) -> str:
+    tokens = data.get("tokens", [])
+    system = data.get("system", {})
+    stats = data.get("stats", {})
+    generated = data.get("generated_at", "unknown")
+
+    lines = [f"Pythia Oracle — Health Report ({generated})\n"]
+
+    incidents = stats.get("active_incidents", 0)
+    lines.append(
+        f"  *** {incidents} ACTIVE INCIDENT(S) ***\n"
+        if incidents > 0
+        else "  No active incidents.\n"
+    )
+
+    sources = system.get("sources", [])
+    for s in sources:
+        marker = " " if s["status"] == "ok" else "!"
+        lines.append(f" {marker} {s['name']:<15} {s['status']}")
+    lines.append("")
+
+    lines.append(f"{'Token':<8} {'Uptime 30d':>10}  {'Status':<6}  {'Src':>3}")
+    lines.append("-" * 40)
+    for t in sorted(tokens, key=lambda x: x.get("uptime_30d", 0)):
+        uptime = (
+            f"{t['uptime_30d']:.1f}%"
+            if t.get("uptime_30d") is not None
+            else "?"
+        )
+        lines.append(
+            f"{t['symbol']:<8} {uptime:>10}  "
+            f"{t.get('status', '?'):<6}  {t.get('sources', '?'):>3}"
+        )
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Tool: Contracts
+# ---------------------------------------------------------------------------
+
+
+class PythiaContractsTool(BaseTool):
+    """Get Pythia contract addresses for on-chain integration."""
+
+    name: str = "pythia_contracts"
+    description: str = (
+        "Get Pythia Oracle contract addresses on Polygon for smart contract "
+        "integration. Returns operator, LINK token, faucet, and consumer "
+        "contract addresses for all pricing tiers."
+    )
+
+    def _run(
+        self, run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> str:
+        return json.dumps(CONTRACTS, indent=2)
+
+    async def _arun(
+        self, run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        return json.dumps(CONTRACTS, indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Tool: Pricing
+# ---------------------------------------------------------------------------
+
+
+class PythiaPricingTool(BaseTool):
+    """Get Pythia Oracle pricing tiers and free trial info."""
+
+    name: str = "pythia_pricing"
+    description: str = (
+        "Get Pythia Oracle pricing tiers (Discovery 0.01 LINK, Analysis "
+        "0.03, Speed 0.05, Complete 0.10) and free trial faucet info."
+    )
+
+    def _run(
+        self, run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> str:
+        return _PRICING_TEXT
+
+    async def _arun(
+        self, run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        return _PRICING_TEXT
+
+
+_PRICING_TEXT = """Pythia Oracle Pricing
+
+  DISCOVERY — 0.01 LINK: Any single indicator. Returns uint256.
+  ANALYSIS  — 0.03 LINK: All 1H/1D/1W indicators bundled. Returns uint256[].
+  SPEED     — 0.05 LINK: All 5-minute indicators bundled. Returns uint256[].
+  COMPLETE  — 0.10 LINK: Every indicator for a token. Returns uint256[].
+
+  FREE TRIAL — PythiaFaucet (0x640fC3B9B607E324D7A3d89Fcb62C77Cc0Bd420A)
+  No LINK needed. 5 requests/day/address. Real data.
+
+  Website: https://pythia.c3x-solutions.com"""

langchain_pythia-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-pythia"
+version = "0.1.0"
+description = "LangChain integration for Pythia Oracle — on-chain calculated crypto indicators (EMA, RSI, Bollinger, Volatility) via Chainlink"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Pythia Oracle", email = "ivan.jeremic@c3x-solutions.com" },
+]
+keywords = [
+    "langchain", "oracle", "chainlink", "defi", "crypto",
+    "ema", "rsi", "bollinger", "volatility", "on-chain",
+    "technical-analysis", "ai-agent", "smart-contracts",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Office/Business :: Financial",
+]
+dependencies = [
+    "langchain-core>=1.2.21,<2.0.0",
+    "httpx>=0.25.0,<1.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.20",
+]
+
+[project.urls]
+Homepage = "https://pythia.c3x-solutions.com"
+Repository = "https://github.com/pythia-the-oracle/langchain-pythia"
+Documentation = "https://github.com/pythia-the-oracle/langchain-pythia#readme"

langchain_pythia-0.1.0/tests/unit_tests/test_tools.py

@@ -0,0 +1,68 @@
+"""Unit tests for Pythia Oracle LangChain tools."""
+
+from langchain_pythia import (
+    PythiaListTokensTool,
+    PythiaTokenFeedsTool,
+    PythiaHealthCheckTool,
+    PythiaContractsTool,
+    PythiaPricingTool,
+)
+
+
+def test_tool_names():
+    """Each tool has a unique, descriptive name."""
+    tools = [
+        PythiaListTokensTool(),
+        PythiaTokenFeedsTool(),
+        PythiaHealthCheckTool(),
+        PythiaContractsTool(),
+        PythiaPricingTool(),
+    ]
+    names = [t.name for t in tools]
+    assert len(names) == len(set(names)), "Tool names must be unique"
+    for name in names:
+        assert name.startswith("pythia_"), f"Tool name should start with pythia_: {name}"
+
+
+def test_tool_descriptions():
+    """Each tool has a non-empty description."""
+    tools = [
+        PythiaListTokensTool(),
+        PythiaTokenFeedsTool(),
+        PythiaHealthCheckTool(),
+        PythiaContractsTool(),
+        PythiaPricingTool(),
+    ]
+    for tool in tools:
+        assert len(tool.description) > 20, f"Description too short for {tool.name}"
+
+
+def test_contracts_tool_returns_json():
+    """Contracts tool returns valid JSON with expected keys."""
+    import json
+
+    tool = PythiaContractsTool()
+    result = tool._run()
+    data = json.loads(result)
+    assert "operator" in data
+    assert "faucet" in data
+    assert "consumers" in data
+    assert "discovery" in data["consumers"]
+
+
+def test_pricing_tool_returns_tiers():
+    """Pricing tool mentions all 4 tiers."""
+    tool = PythiaPricingTool()
+    result = tool._run()
+    assert "DISCOVERY" in result
+    assert "ANALYSIS" in result
+    assert "SPEED" in result
+    assert "COMPLETE" in result
+    assert "FREE TRIAL" in result
+
+
+def test_token_feeds_input_schema():
+    """Token feeds tool has proper input schema."""
+    tool = PythiaTokenFeedsTool()
+    schema = tool.args_schema.model_json_schema()
+    assert "engine_id" in schema["properties"]