Metadata-Version: 2.4
Name: aios-framework
Version: 0.1.0
Summary: Mini-framework en Python para registrar herramientas y generar manifests que describen capacidades de aplicaciones para IA.
Author: Kenyi Galindo
License: MIT
Project-URL: Homepage, https://github.com/KenyiGM/aios
Project-URL: Repository, https://github.com/KenyiGM/aios
Project-URL: Issues, https://github.com/KenyiGM/aios/issues
Keywords: ai,ai-tools,llm,ai-agents,manifest,ai-operating-system,python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Libraries
Requires-Python: >=3.10
Description-Content-Type: text/markdown

# AIOS

**AIOS** significa **AI Operating System**.

Es un concepto para construir aplicaciones que puedan **exponer sus capacidades de forma estructurada para sistemas de inteligencia artificial**, permitiendo que agentes o modelos de IA interactúen con ellas de manera clara y controlada.

La idea principal es que una aplicación pueda describir **qué puede hacer**, en lugar de que una IA tenga que analizar todo su código.


# Arquitectura del proyecto

El proyecto AIOS está compuesto por diferentes componentes.

Actualmente incluye:

``` 
AIOS
│
└─ aios (mini-framework)
    │
    └─ ai_tools (recurso disponible)
        │
        └─ tools registradas por la aplicación
```

# aios (mini-framework)

`aios` es un pequeño framework en Python diseñado para **registrar y describir herramientas de una aplicación**.

Estas herramientas representan capacidades del sistema que una IA podría utilizar.

El framework permite:

- registrar herramientas
- describirlas con metadata
- generar un manifest JSON
- exponer las capacidades del sistema a agentes de IA

El framework **no ejecuta IA**, solo describe el sistema.


# ai_tools

`ai_tools` es el primer recurso disponible dentro de AIOS.

Este recurso representa **las herramientas que una aplicación ofrece a una IA**.

Cada herramienta describe:
- qué hace
- qué parámetros recibe
- qué devuelve
- etiquetas o categorías
- permisos requeridos
- prioridad
- posibles flujos de acción

# Instalacion
Actualmente `aios` se utiliza directamente desde el código fuente.

## 1. Clonar el repositorio

```bash
git clone https://github.com/KenyiGM/aios.git
```
## 2. Creacion de entorno virtual (Opcional)

```bash
python -m venv venv
```
### Activar el entorno

Linux/macOS
```bash
source venv/bin/activate
```
Windows
```bash
venv\Scripts\activate
```
### Instalar el modulo
```bash
pip install git+https://github.com/KenyiGM/aios.git
```

# Quick Start

Este ejemplo muestra cómo crear una pequeña aplicación que expone herramientas para IA usando `aios`.

## 1. Importar AIOS

```python
from aios import AiTools
```

## 2. Crear una aplicación

```python
app = AiTools(
    name="notas",
    description="Sistema simple de notas"
)
```

La aplicación actuará como contenedor de herramientas.

## 3. Definir una herramienta

Las herramientas se registran usando el decorador ai_action.

```python
@app.ai_action(tags=["nota"])
def crear_nota(titulo: str, contenido: str, ai_tools: AiTools):
    """Crea una nueva nota"""

    notas = ai_tools.get_context("notas", namespace="data", default=[])

    notas.append({
        "titulo": titulo,
        "contenido": contenido
    })

    ai_tools.set_context("notas", notas, namespace="data")

    return f"Nota '{titulo}' creada"
```

La función se convierte automáticamente en una tool disponible para la aplicación.

## 4. Ejecutar una herramienta

Las herramientas pueden ejecutarse desde código usando ai_executor.

```python
app.ai_executor(
    "notas.crear_nota",
    titulo="Idea IA",
    contenido="Crear un framework de tools"
)
```

## 5. Generar el manifest del sistema

AIOS puede describir las capacidades de la aplicación en formato JSON.

```python
schema = app.generate_schema()
print(schema)
```

También se puede guardar como archivo:

```python
app.save_manifest()
```

Esto generará:

```bash
manifest/ai_manifest.json
```

El manifest permite que agentes o modelos de IA descubran las herramientas disponibles.

## 6. Exportar herramientas para LLM

AIOS también puede exportar las herramientas en formato compatible con LLM function calling.

```python 
tools = app.export_openai_tools()
print(tools)
```

## 7. Ejemplo Completo

```python
from aios import AiTools

app = AiTools(
    name="notas",
    description="Sistema simple de notas"
)

app.set_context("notas", [], namespace="data")

@app.ai_action(tags=["nota"])
def crear_nota(titulo: str, contenido: str, ai_tools: AiTools):
    """Crea una nueva nota"""

    notas = ai_tools.get_context("notas", namespace="data", default=[])

    notas.append({
        "titulo": titulo,
        "contenido": contenido
    })

    ai_tools.set_context("notas", notas, namespace="data")

    return f"Nota '{titulo}' creada"

print(
    app.ai_executor(
        "notas.crear_nota",
        titulo="Idea IA",
        contenido="Crear un framework de tools"
    )
)

print(app.generate_schema())
```

# Concepto

Se explica las ideas basicas del sistema.

## App

Una App es la instancia principal de AIOS.

Representa una aplicación que expone capacidades para ser utilizadas por sistemas de IA.

```python
app = AiTools(
    name="notas",
    description="Sistema simple de notas"
)
```

La app es responsable de:

- registrar herramientas

- mantener el contexto

- generar el manifest del sistema

- ejecutar herramientas

## Module

Un Module agrupa herramientas relacionadas.

Por ejemplo:

- notas
- usuarios
- archivos
- agenda

Cada módulo describe un conjunto de capacidades dentro de la aplicación.

En AIOS, el nombre del módulo forma parte de la ruta de la herramienta.

Ejemplo:
```python
notas.crear_nota
notas.listar_notas
```

## Tool

Una Tool representa una acción que la aplicación puede realizar.

Las tools se definen como funciones Python registradas con ai_action.

```python
@app.ai_action(tags=["nota"])
def crear_nota(titulo: str, contenido: str):
```

Cada tool describe:

- qué hace
 
- qué parámetros recibe

- qué devuelve

- metadata adicional (tags, permisos, prioridad, etc.)

Las tools son las capacidades que una IA puede utilizar.

## Context

El Context es un almacenamiento interno que permite compartir estado entre herramientas.

Ejemplo:

```python
app.set_context("notas", [], namespace="data")
```

Luego una herramienta puede acceder a ese estado:

```python 
notas = ai_tools.get_context("notas", namespace="data")
```

Esto permite construir herramientas que trabajen con información persistente durante la ejecución.

## Manifest

El Manifest es una descripción estructurada de todas las capacidades de la aplicación.

AIOS puede generarlo automáticamente:

```python
app.generate_schema()
```

O guardarlo en un archivo:

```python
app.save_manifest()
```

El manifest permite que agentes de IA puedan descubrir las herramientas disponibles sin analizar el código fuente.

## Routes

Cada tool tiene una ruta única dentro del sistema.

Formato:

```python
module.tool
```

Ejemplo:

```python
notas.crear_nota
notas.listar_notas
```

Estas rutas son utilizadas para ejecutar herramientas dinámicamente:

```python
app.ai_executor("notas.crear_nota", titulo="Idea", contenido="...")
```

# Licencia

MIT
