semvec/pypi-packages huggingface dataset:
ada-agentic 0.1.0
Ayala Agentic AI - MCP Server Implementation
Requires Python: >=3.10

# Ayala Agentic AI

A [Model Context Protocol](https://modelcontextprotocol.io/) server
implementation for the Ayala Agentic AI project. This enables AI agents to
query for context across many sources.

## Features

- A common Agentic AI reference architecture (or platform in the future) for
  Ayala Group
- Powered by open standard agent protocols, it enables LLM-powered agents to
  reliably locate context, invoke tools, and collaborate with other AI agents
  within the Ayala Group technology landscape
- It provides an "agentic layer" to Ayala Group data platforms such as Open
  Data, Concati, Inquiro, and GShare
- It unlocks potential synergies through a common AI technology framework
  (context sharing vs. data sharing)
- It will natively support widely used LLM clients such as ChatGPT, Claude,
  and Gemini

## Design Principles

- **Ease-of-Use**: Support existing AI client apps (ChatGPT, Copilot, Claude)
  instead of building new ones
- **Cost Efficiency**: Allow web-based interface for non-license users and for
  cost-sensitive BUs
- **Flexibility**: Use open-standard agent protocols for integration (MCP, A2A,
  etc.)
- **Synergy**: Work with Ayala Group platforms and initiatives such as Concati,
  Inquiro, and Open Data
- **Governance-First**: Build AI governance requirements into the platform's
  foundational design rather than retrofitting compliance capabilities
  (Mosaic, MLFlow, etc.)

## Architecture

The Ayala AI Assistant (MCP) serves as the central hub connecting various
agentic models with context and tools providers across the Ayala Group
ecosystem.

![Ayala Agentic AI Architecture](../../doc/img/architecture-agentic.png)

### Components

**Agentic Models:**
- ChatGPT - OpenAI's conversational AI model
- Claude - Anthropic's AI assistant
- Databricks - MLOps and data science platform

**Context and Tools Providers:**
- Systems of Record - Core business systems and databases
- Ayala Open Data - Centralized data platform for the Ayala Group
- Concati / Inquiro - Data discovery and analytics platforms

The architecture enables seamless integration between AI models and Ayala's
data ecosystem, providing a unified interface for AI-powered business
operations.

## Developing

### Setup

Requires [`uv`](https://docs.astral.sh/uv/) - see the
[project README](README.md) for installation instructions.

```bash
make setup
```

### Run using the MCP inspector

```bash
source .venv/bin/activate

mcp dev src/agentic/__main__.py
```

### Run using an MCP client

Use this configuration in your MCP client (e.g., Claude Desktop, Cursor, etc.):

```js
{
  "mcpServers": {
    "agentic": {
      "command": "<full-path-to-uv>",  // e.g. /Users/username/.local/bin/uv
      "args": [
        "--directory",
        "path/to/agentic",  // update this with an absolute path
        "run",
        "agentic"
      ]
    }
  }
}
```

### Run tests

```bash
make test
```

## Publishing

```bash
export UV_PUBLISH_TOKEN=...
make publish
```
retrytools 0.0.3.post1
A Python decorator for retrying functions with exponential backoff, optional jitter, and support for both sync and async code.
Requires Python: >=3.7

# 🌀 Retry Tools

A Python decorator for **retrying functions** with **exponential backoff**, **optional jitter**, and full support for **both synchronous and asynchronous** code.


## 🔍 About

This library provides a simple yet powerful `@retry` decorator that retries a function when specified exceptions are raised. It supports:

* **Synchronous and asynchronous functions**
* **Exponential backoff** with optional **jitter**
* **Custom exception handling**
* **Logging or custom log output**

Useful for handling flaky APIs, intermittent database errors, or any transient issues where retrying helps.


## 📦 Installation

```bash
pip install retrytools
```


## 🚀 Quick Start

### Basic Usage

```python
from retrytools import retry

@retry(catch_errors=ValueError, tries=3, delay=1)
def flaky_function():
    # Simulates an error-prone operation
    if random.random() < 0.7:
        raise ValueError("Transient issue!")
    return "Success!"

result = flaky_function()
print(result)
```


### With Async Function

```python
import asyncio
from retrytools import retry

@retry(catch_errors=ConnectionError, tries=5, delay=0.5)
async def unstable_async_api():
    if random.random() < 0.5:
        raise ConnectionError("Temporary network glitch")
    return "Fetched!"

asyncio.run(unstable_async_api())
```

## ⚙️ Parameters

| Argument       | Type                          | Description                                                        |
| -------------- | ----------------------------- | ------------------------------------------------------------------ |
| `catch_errors` | `Type[Exception]` or tuple    | Exception(s) to retry on                                           |
| `tries`        | `int`                         | Max attempts (default: 3)                                          |
| `delay`        | `float`                       | Initial delay in seconds                                           |
| `throw_error`  | `Exception` (optional)        | Custom error to raise after final failure                          |
| `logger`       | `Logger` or `Callable[[str]]` | Logging handler (e.g., `print` or `logging.Logger`)                |
| `jitter`       | `bool` or `float`             | Random delay variation: `True` for full jitter, float for additive |


## 📝 Example with Logging

```python
import logging
from retrytools import retry

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

@retry(catch_errors=(RuntimeError, ConnectionError), tries=4, throw_error=Exception("Custom"), delay=2, logger=logger, jitter=True)
def sometimes_fails():
    if random.randint(0, 1):
        raise RuntimeError("Oops!")
    return "Got it!"

sometimes_fails()
```


## 📌 Notes

* **Jitter** is helpful to avoid retry storms in distributed systems.
* Supports Python 3.7+.
* Works transparently for both sync and async code.


## 🛠️ License

MIT License