AI_agent/AIagent/README.md

# Système d'Agents Ollama

Ce projet fournit un framework pour créer et gérer des agents d'IA basés sur les modèles Ollama. Il permet d'utiliser facilement différents types de modèles (texte, code, vision, embeddings) et de paramétrer leur comportement.

## Fonctionnalités

- Utilisation de l'API Ollama pour interagir avec les modèles locaux
- Classes spécialisées pour différents types de modèles :
  - Génération de texte (TextGenerationModel)
  - Multimodal avec support d'images (MultiModalModel)
  - Embeddings (EmbeddingModel)
- Système de gestion d'agents pour organiser plusieurs modèles
- Contrôle précis des paramètres de génération (température, top_p, top_k, etc.)
- Support du streaming pour des réponses progressives
- Support de l'API chat pour des conversations contextuelles

## Prérequis

- Python 3.8+
- [Ollama](https://ollama.ai/) installé et en cours d'exécution
- Modèles Ollama téléchargés (voir [ollama.ai/library](https://ollama.ai/library))
- Module `requests` de Python

## Installation

1. Clonez ce dépôt :
```
git clone <url-du-depot>
cd AIagent
```

2. Installez les dépendances :
```
pip install requests
```

3. Assurez-vous qu'Ollama est en cours d'exécution sur votre serveur.

## Structure du projet

```
AIagent/
├── src/
│   ├── ollama_models.py  # Classes de base et spécialisées pour les modèles
│   └── exemple_usage.py  # Exemples d'utilisation
└── README.md
```

## Utilisation

### Configuration de base

```python
from src.ollama_models import AgentSystem, create_text_agent

# Créer le système d'agents
system = AgentSystem()

# Ajouter un agent de génération de texte
create_text_agent(
    agent_id="assistant",
    model_name="llama3.3:70b-instruct-q8_0",
    system=system,
    temperature=0.7,
    top_p=0.9
)

# Récupérer l'agent et l'utiliser
agent = system.get_agent("assistant")
response = agent.generate("Explique-moi le fonctionnement des grands modèles de langage.")
```

### Génération de texte

```python
# Créer directement un modèle sans système d'agents
from src.ollama_models import TextGenerationModel

model = TextGenerationModel(
    model_name="llama3.3:70b-instruct-q8_0",
    temperature=0.7
)

# Générer du texte
response = model.generate("Écris un poème sur l'intelligence artificielle.")
```

### Chat conversationnel

```python
# Utiliser l'API chat
messages = [
    {"role": "system", "content": "Tu es un assistant IA serviable et concis."},
    {"role": "user", "content": "Quels sont les avantages des modèles Ollama?"}
]

response = model.chat(messages)

# Continuer la conversation
messages.append({"role": "assistant", "content": response})
messages.append({"role": "user", "content": "Et quels sont les inconvénients?"})

response = model.chat(messages)
```

### Utilisation de modèles multimodaux

```python
from src.ollama_models import MultiModalModel

vision_model = MultiModalModel(
    model_name="llava:34b-v1.6-fp16",
    temperature=0.8
)

# Analyser une image
response = vision_model.analyze_image(
    prompt="Décris cette image en détail.",
    image_path="chemin/vers/image.jpg"
)
```

### Génération d'embeddings

```python
from src.ollama_models import EmbeddingModel

embedding_model = EmbeddingModel(
    model_name="nomic-embed-text:137m-v1.5-fp16"
)

# Obtenir des embeddings
embeddings = embedding_model.get_embeddings([
    "Premier texte à encoder",
    "Second texte à encoder"
])
```

## Paramètres des modèles

Voici les principaux paramètres que vous pouvez ajuster :

- `temperature` (0.0-1.0) : Contrôle la créativité/aléatoire du modèle
- `top_p` (0.0-1.0) : Échantillonnage du nucleus, affecte la diversité
- `top_k` (1-100) : Limite les tokens considérés aux k plus probables
- `num_ctx` (int) : Taille du contexte en tokens
- `num_predict` (int) : Nombre maximum de tokens à générer
- `repeat_penalty` (float) : Pénalité pour les répétitions

Pour mettre à jour les paramètres d'un modèle :

```python
model.update_options(
    temperature=0.2,
    top_p=0.8,
    num_predict=500
)
```

## Exemple complet

Consultez le fichier `src/exemple_usage.py` pour un exemple complet d'utilisation.

Pour exécuter l'exemple :

```
python src/exemple_usage.py
```

## Modèles supportés

Ce système prend en charge tous les modèles disponibles via Ollama. Voici quelques exemples :

- Modèles de texte : llama3.3, qwen2.5, etc.
- Modèles de vision : llava, llama3.2-vision, etc.
- Modèles d'embeddings : nomic-embed-text, etc.

## Licence

[MIT](LICENSE)