fonky 0.1.0

fonky

Purpose  |  Architecture  |  Structure  |  Installation  |  Integrations  |  Tool Index  |  User Guide  |  Configuration  | 

🎯 Purpose

Fonky is a Python library that provides a unified collection of reusable tools for AI, data acquisition, document processing, web access, geospatial analysis, environmental data, and other common application workflows. It helps solve the problem of repeatedly implementing and maintaining provider-specific integrations by encapsulating existing loaders, fetchers, scrapers, preprocessors, and related utilities behind consistent, easy-to-call interfaces. Fonky can be imported directly into Python applications, notebooks, automation pipelines, or AI-agent frameworks, allowing developers to invoke individual tools as ordinary functions or expose them through provider-specific integrations such as GPT, Claude, Gemini, Grok, Mistral, and LangChain without duplicating the underlying implementation.

🛠️ Architecture

🔁 Workflow

📦 Package Structure

fonky/
├── __init__.py
├── boogr.py
├── config.py
├── fetchers.py
├── loaders.py
├── models.py
├── processors.py
├── scrapers.py
├── gpt/
│   ├── __init__.py
│   └── tools.py
├── claude/
│   ├── __init__.py
│   └── tools.py
├── gemini/
│   ├── __init__.py
│   └── tools.py
├── grok/
│   ├── __init__.py
│   └── tools.py
├── mistral/
│   ├── __init__.py
│   └── tools.py
└── langchain/
    ├── __init__.py
    └── tools.py

⚙️ Installation

python -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip wheel
python -m pip install fonky
python -m pip check

For an editable development installation from a repository checkout:

python -m pip install -e .

Playwright

python -m playwright install chromium

🔑 Configuration and API Keys

API Key Set-up Instructions

Environment Variables

🤖 Provider Integrations

OpenAI Agents SDK

from agents import Agent, Runner

from fonky.gpt.tools import fetch_arxiv
from fonky.gpt.tools import fetch_wikipedia

agent = Agent(
    name='Research Assistant',
    instructions='Use the supplied Fonky tools when required.',
    tools=[
        fetch_arxiv,
        fetch_wikipedia,
    ] )

result = Runner.run_sync(
    agent,
    'Research retrieval augmented generation.' )

print( result.final_output )

Anthropic Claude

Fonky exposes a direct Anthropic integration through fonky.claude.tools. Each public Claude tool is decorated with Anthropic's @beta_tool and delegates directly to the canonical Fonky implementation in fetchers.py, loaders.py, scrapers.py, or processors.py.

from anthropic import Anthropic

from fonky.claude.tools import fetch_arxiv
from fonky.claude.tools import fetch_wikipedia

client = Anthropic()

tools = [
    fetch_arxiv.to_dict(),
    fetch_wikipedia.to_dict(),
]

response = client.beta.messages.create(
    model='claude-sonnet-4-6',
    max_tokens=4096,
    tools=tools,
    messages=[
        {
            'role': 'user',
            'content': 'Research retrieval augmented generation.',
        },
    ] )

print( response )

The Claude adapter does not depend on fonky.gpt or unwrap another provider's tools. It exposes the same Fonky operations as native Anthropic beta_tool objects while preserving the underlying implementation signatures, defaults, documentation, and behavior.

Structured tool results: Anthropic's automatic Tool Runner expects tool results to be strings or supported Anthropic content blocks. Fonky tools that return dictionaries, DataFrames, NumPy arrays, document collections, or other structured Python values retain those native return types. Applications using those tools in an Anthropic tool-result loop should serialize the returned value before sending it back to Claude.

Google ADK

from google.adk.agents import Agent

from fonky.gemini.tools import fetch_arxiv
from fonky.gemini.tools import fetch_wikipedia

agent = Agent(
    name='research_assistant',
    model='gemini-3.7-flash',
    instruction='Use the supplied Fonky tools when required.',
    tools=[
        fetch_arxiv,
        fetch_wikipedia,
    ] )

xAI Grok

from fonky.grok.tools import cse_search_tool
from fonky.grok.tools import fetch_cse_search

tools = [
    cse_search_tool,
]

# Pass ``tools`` to the xAI chat request.
# When Grok requests ``fetch_cse_search``, execute the callable locally:
result = fetch_cse_search(
    keywords='federal appropriations law',
    results=5 )

Mistral AI

Fonky exposes executable wrappers and Mistral-compatible JSON function declarations through fonky.mistral.tools. Each declaration is paired with a callable that delegates directly to the canonical Fonky implementation.

from mistralai.client import Mistral

from fonky.config import MISTRAL_API_KEY
from fonky.mistral.tools import cse_search_tool
from fonky.mistral.tools import fetch_cse_search

client = Mistral(
    api_key=MISTRAL_API_KEY )

tools = [
    cse_search_tool,
]

response = client.chat.complete(
    model='mistral-medium-latest',
    messages=[
        {
            'role': 'user',
            'content': 'Find sources about federal appropriations law.',
        },
    ],
    tools=tools )

result = fetch_cse_search(
    keywords='federal appropriations law',
    results=5 )

print( response )
print( result )

When Mistral returns a tool call, the application executes the matching Fonky callable locally and returns a serialized tool-result message. Fonky preserves canonical return types, so dictionaries, DataFrames, NumPy arrays, and document collections must be serialized by the calling workflow.

LangChain

from fonky.langchain.tools import fetch_arxiv
from fonky.langchain.tools import fetch_wikipedia

tools = [
    fetch_arxiv,
    fetch_wikipedia,
]

📚 Documentation

• Tools Reference
• User Guide
• MkDocs Site

📝 License