mirror of
https://github.com/Ladebeze66/AI_agent.git
synced 2025-12-15 19:16:49 +01:00
39 KiB
39 KiB
Création de classes pour modèles Ollama (2025-03-20 16:58:24)
User
j'ai a ma disposition un serveur disposant d'un H100 avec ollama avec différents modèles voici la liste des modèles installés. Je voudrai créer un système de classes avec mes modèles pour pouvoir créer un système d'agent avec la possibilité de pouvoir ajuster les réglages de ces modèles voici la liste de mes modèles: ubuntu@h100-380-gra11:~$ ollama list NAME ID SIZE MODIFIED hf.co/mradermacher/EraX-multilingual-Rerank-3B-V2.0-GGUF:F16 d91cc1ed0d2f 7.2 GB 6 weeks ago cline_deepseek:latest 0bf9bdf65e71 74 GB 7 weeks ago deepseek-r1:70b-llama-distill-q8_0 cc1ba146470d 74 GB 7 weeks ago llava:34b-v1.6-fp16 89c50af82d5e 69 GB 2 months ago llama3.2-vision:90b-instruct-q8_0 e65e1af5e383 95 GB 2 months ago linux6200/bge-reranker-v2-m3:latest abf5c6d8bc56 1.2 GB 2 months ago nomic-embed-text:137m-v1.5-fp16 0a109f422b47 274 MB 2 months ago cline_qwen_fp16:latest 82800e2e3c2e 65 GB 2 months ago cline_qwen_32k_Q8:latest 9a1b09922a53 34 GB 2 months ago llama3.3:70b-instruct-q6_K 992c05c90cd8 57 GB 2 months ago llama3.3:70b-instruct-q8_0 d5b5e1b84868 74 GB 2 months ago cline_qwen_128k_Q8:latest 8675a48afcaf 34 GB 2 months ago hf.co/unsloth/Qwen2.5-Coder-32B-Instruct-128K-GGUF:Q8_0 b249cb8f57ca 34 GB 2 months ago hf.co/bartowski/Rombos-Coder-V2.5-Qwen-32b-GGUF:Q8_0 9a943e73021c 34 GB 2 months ago qwen2.5-coder:32b-instruct-fp16 5955f7d140cd 65 GB 2 months ago qwen2.5-coder:32b-base-q8_0 2888b8e6d633 34 GB 2 months ago qwen2.5:72b-instruct-q8_0 23f2cb48bb9a 77 GB 2 months ago qwen2.5:72b-instruct-q6_K 5f611a49224d 64 GB 2 months ago je ne sais pas comment procéder tu aurais peut etre une idée de comment procédé sachant que je peux me connecter à l'adresse suivante : "http://localhost:11434/api/generate" mais ce qui m'intersse est dans un premier temps de créer des classes avec mes différents modèles et pouvoir les utiliser comment agent
Assistant
Je vais vous aider à créer un système de classes pour vos modèles Ollama. Commençons par explorer l'API d'Ollama pour mieux comprendre comment l'utiliser.
Searched web "ollama api documentation python generate" • **10** results
| Title | URL |
|---|---|
| Ollama Python library | https://github.com/ollama/ollama-python |
| GitHub - ollama/ollama-python: Ollama Python library | https://github.com/ollama/ollama-python/tree/main |
| ollama | https://pypi.org/project/ollama/ |
| Ollama Python library | https://github.com/ollama/ollama-python |
| GitHub - ollama/ollama-python: Ollama Python library | https://github.com/ollama/ollama-python/tree/main |
| ollama/docs/api.md at main · ollama/ollama | https://github.com/ollama/ollama/blob/main/docs/api.md |
| ollama | https://pypi.org/project/ollama/ |
| ollama | https://pypi.org/project/ollama/ |
| GitHub - Mazyod/ollala: (Unofficial) Ollama python SDK. Maintained by GPT. | https://github.com/Mazyod/ollala |
| Ollama Python library | https://github.com/ollama/ollama-python |
Searched web "ollama generate api parameters temperature top_p top_k" • **10** results
Listed current directory • **1** results
| Name |
|---|
📁 AIagent |
Listed directory AIagent • **5** results
| Name |
|---|
📁 bin |
📁 include |
📁 lib |
📄 pyvenv.cfg |
📁 lib64 |
Maintenant, je vais créer un système de classes pour vos modèles Ollama. Je commencerai par créer une structure de base, puis j'ajouterai les fonctionnalités nécessaires.
mkdir -p AIagent/src
fgras-ca@PC-DEV:~/AI_agent$ mkdir -p AIagent/src
fgras-ca@PC-DEV:~/AI_agent$
Maintenant, je vais créer le fichier principal pour notre système de classes de modèles Ollama :
-
+ """
+ Module de gestion des modèles Ollama pour systèmes d'agents IA.
+ Ce module fournit des classes pour interagir avec différents modèles Ollama
+ et paramétrer leurs comportements.
+ """
+
+ import json
+ import requests
+ from typing import List, Dict, Any, Union, Optional
+
+
+ class OllamaModel:
+ """Classe de base pour interagir avec les modèles Ollama."""
+
+ def __init__(self,
+ model_name: str,
+ base_url: str = "http://localhost:11434",
+ temperature: float = 0.7,
+ top_p: float = 0.9,
+ top_k: int = 40,
+ num_ctx: int = 4096,
+ num_predict: int = 128,
+ repeat_penalty: float = 1.1,
+ stream: bool = True):
+ """
+ Initialise un modèle Ollama.
+
+ Args:
+ model_name: Nom du modèle Ollama à utiliser
+ base_url: URL de base de l'API Ollama
+ temperature: Température pour la génération (0.0 à 1.0)
+ top_p: Paramètre top_p pour la génération (0.0 à 1.0)
+ top_k: Paramètre top_k pour la génération (1 à 100)
+ num_ctx: Taille du contexte en tokens
+ num_predict: Nombre maximum de tokens à générer
+ repeat_penalty: Pénalité pour les répétitions
+ stream: Si True, utilise le streaming pour les réponses
+ """
+ self.model_name = model_name
+ self.base_url = base_url
+ self.api_url = f"{base_url}/api"
+
+ # Paramètres du modèle
+ self.options = {
+ "temperature": temperature,
+ "top_p": top_p,
+ "top_k": top_k,
+ "num_ctx": num_ctx,
+ "num_predict": num_predict,
+ "repeat_penalty": repeat_penalty
+ }
+
+ self.stream = stream
+
+ def generate(self, prompt: str) -> Union[str, Dict[str, Any]]:
+ """
+ Génère une réponse à partir d'un prompt.
+
+ Args:
+ prompt: Le texte à soumettre au modèle
+
+ Returns:
+ La réponse du modèle (texte ou dictionnaire complet)
+ """
+ url = f"{self.api_url}/generate"
+
+ payload = {
+ "model": self.model_name,
+ "prompt": prompt,
+ "stream": self.stream,
+ "options": self.options
+ }
+
+ try:
+ if self.stream:
+ return self._stream_response(url, payload)
+ else:
+ response = requests.post(url, json=payload)
+ response.raise_for_status()
+ return response.json()
+ except Exception as e:
+ return f"Erreur lors de la génération: {str(e)}"
+
+ def _stream_response(self, url: str, payload: Dict[str, Any]) -> str:
+ """
+ Gère le streaming de la réponse et renvoie le texte complet.
+
+ Args:
+ url: URL de l'API
+ payload: Données pour la requête
+
+ Returns:
+ La réponse complète sous forme de texte
+ """
+ full_response = ""
+ try:
+ with requests.post(url, json=payload, stream=True) as response:
+ response.raise_for_status()
+ for line in response.iter_lines():
+ if line:
+ chunk = json.loads(line)
+ if "response" in chunk:
+ print(chunk["response"], end="", flush=True)
+ full_response += chunk["response"]
+ if chunk.get("done", False):
+ break
+ print() # Nouvelle ligne après la réponse
+ return full_response
+ except Exception as e:
+ return f"Erreur lors du streaming: {str(e)}"
+
+ def chat(self, messages: List[Dict[str, str]]) -> Union[str, Dict[str, Any]]:
+ """
+ Utilise l'API chat pour communiquer avec le modèle.
+
+ Args:
+ messages: Liste de messages au format [{"role": "user", "content": "..."}]
+
+ Returns:
+ La réponse du modèle
+ """
+ url = f"{self.api_url}/chat"
+
+ payload = {
+ "model": self.model_name,
+ "messages": messages,
+ "stream": self.stream,
+ "options": self.options
+ }
+
+ try:
+ if self.stream:
+ return self._stream_chat_response(url, payload)
+ else:
+ response = requests.post(url, json=payload)
+ response.raise_for_status()
+ return response.json()
+ except Exception as e:
+ return f"Erreur lors du chat: {str(e)}"
+
+ def _stream_chat_response(self, url: str, payload: Dict[str, Any]) -> str:
+ """
+ Gère le streaming de la réponse de chat et renvoie le texte complet.
+
+ Args:
+ url: URL de l'API
+ payload: Données pour la requête
+
+ Returns:
+ La réponse complète sous forme de texte
+ """
+ full_response = ""
+ try:
+ with requests.post(url, json=payload, stream=True) as response:
+ response.raise_for_status()
+ for line in response.iter_lines():
+ if line:
+ chunk = json.loads(line)
+ if "message" in chunk and "content" in chunk["message"]:
+ content = chunk["message"]["content"]
+ print(content, end="", flush=True)
+ full_response += content
+ if chunk.get("done", False):
+ break
+ print() # Nouvelle ligne après la réponse
+ return full_response
+ except Exception as e:
+ return f"Erreur lors du streaming du chat: {str(e)}"
+
+ def embed(self, input_text: Union[str, List[str]]) -> Dict[str, Any]:
+ """
+ Génère des embeddings pour un texte.
+
+ Args:
+ input_text: Texte ou liste de textes pour lesquels générer des embeddings
+
+ Returns:
+ Réponse contenant les embeddings
+ """
+ url = f"{self.api_url}/embed"
+
+ payload = {
+ "model": self.model_name,
+ "prompt": input_text
+ }
+
+ try:
+ response = requests.post(url, json=payload)
+ response.raise_for_status()
+ return response.json()
+ except Exception as e:
+ return {"error": str(e)}
+
+ def update_options(self, **kwargs):
+ """
+ Met à jour les options du modèle.
+
+ Args:
+ **kwargs: Paires clé-valeur de paramètres à mettre à jour
+ """
+ for key, value in kwargs.items():
+ if key in self.options:
+ self.options[key] = value
+
+ @staticmethod
+ def list_models() -> Dict[str, Any]:
+ """
+ Liste tous les modèles disponibles.
+
+ Returns:
+ Dictionnaire contenant les informations sur les modèles disponibles
+ """
+ try:
+ response = requests.get("http://localhost:11434/api/tags")
+ response.raise_for_status()
+ return response.json()
+ except Exception as e:
+ return {"error": str(e)}
+
+
+ class TextGenerationModel(OllamaModel):
+ """Classe spécialisée pour les modèles de génération de texte."""
+
+ def __init__(self, model_name: str, **kwargs):
+ super().__init__(model_name, **kwargs)
+
+ def create_completion(self, prompt: str, max_tokens: int = None) -> str:
+ """
+ Crée une complétion de texte simple.
+
+ Args:
+ prompt: Le texte à compléter
+ max_tokens: Nombre maximum de tokens à générer (remplace num_predict si spécifié)
+
+ Returns:
+ Le texte généré
+ """
+ # Sauvegarde des options existantes
+ original_options = self.options.copy()
+
+ if max_tokens is not None:
+ self.options["num_predict"] = max_tokens
+
+ result = self.generate(prompt)
+
+ # Restauration des options d'origine
+ self.options = original_options
+
+ if isinstance(result, str):
+ return result
+ elif isinstance(result, dict) and "response" in result:
+ return result["response"]
+ else:
+ return str(result)
+
+
+ class MultiModalModel(OllamaModel):
+ """Classe pour les modèles multimodaux prenant en charge les images."""
+
+ def __init__(self, model_name: str, **kwargs):
+ super().__init__(model_name, **kwargs)
+
+ def analyze_image(self, prompt: str, image_path: str) -> str:
+ """
+ Analyse une image et répond à une question à son sujet.
+
+ Args:
+ prompt: La question ou instruction concernant l'image
+ image_path: Chemin vers le fichier image à analyser
+
+ Returns:
+ La réponse du modèle à propos de l'image
+ """
+ import base64
+
+ # Lire et encoder l'image en base64
+ try:
+ with open(image_path, "rb") as image_file:
+ image_data = base64.b64encode(image_file.read()).decode("utf-8")
+ except Exception as e:
+ return f"Erreur lors de la lecture de l'image: {str(e)}"
+
+ url = f"{self.api_url}/generate"
+
+ payload = {
+ "model": self.model_name,
+ "prompt": prompt,
+ "stream": self.stream,
+ "options": self.options,
+ "images": [image_data]
+ }
+
+ try:
+ if self.stream:
+ return self._stream_response(url, payload)
+ else:
+ response = requests.post(url, json=payload)
+ response.raise_for_status()
+ result = response.json()
+ return result.get("response", str(result))
+ except Exception as e:
+ return f"Erreur lors de l'analyse de l'image: {str(e)}"
+
+
+ class EmbeddingModel(OllamaModel):
+ """Classe spécialisée pour les modèles d'embedding."""
+
+ def __init__(self, model_name: str, **kwargs):
+ super().__init__(model_name, **kwargs)
+
+ def get_embeddings(self, texts: Union[str, List[str]]) -> List[List[float]]:
+ """
+ Obtient des embeddings pour un ou plusieurs textes.
+
+ Args:
+ texts: Texte unique ou liste de textes
+
+ Returns:
+ Liste des vecteurs d'embedding
+ """
+ result = self.embed(texts)
+
+ if "error" in result:
+ print(f"Erreur: {result['error']}")
+ return []
+
+ if "embedding" in result:
+ # Cas d'un seul texte
+ return [result["embedding"]]
+ elif "embeddings" in result:
+ # Cas d'une liste de textes
+ return result["embeddings"]
+ else:
+ print(f"Format de réponse inattendu: {result}")
+ return []
+
+
+ class AgentSystem:
+ """Système de gestion d'agents basés sur les modèles Ollama."""
+
+ def __init__(self):
+ self.agents = {}
+
+ def add_agent(self, agent_id: str, model: OllamaModel):
+ """
+ Ajoute un agent au système.
+
+ Args:
+ agent_id: Identifiant unique pour l'agent
+ model: Modèle Ollama à utiliser pour cet agent
+ """
+ self.agents[agent_id] = model
+
+ def get_agent(self, agent_id: str) -> Optional[OllamaModel]:
+ """
+ Récupère un agent par son ID.
+
+ Args:
+ agent_id: Identifiant de l'agent
+
+ Returns:
+ L'instance du modèle associée à l'agent, ou None si non trouvé
+ """
+ return self.agents.get(agent_id)
+
+ def remove_agent(self, agent_id: str) -> bool:
+ """
+ Supprime un agent du système.
+
+ Args:
+ agent_id: Identifiant de l'agent à supprimer
+
+ Returns:
+ True si l'agent a été supprimé, False sinon
+ """
+ if agent_id in self.agents:
+ del self.agents[agent_id]
+ return True
+ return False
+
+ def list_agents(self) -> Dict[str, str]:
+ """
+ Liste tous les agents disponibles.
+
+ Returns:
+ Dictionnaire avec ID d'agent comme clé et nom du modèle comme valeur
+ """
+ return {agent_id: agent.model_name for agent_id, agent in self.agents.items()}
+
+
+ # Fonctions auxiliaires pour créer facilement des agents
+
+ def create_text_agent(agent_id: str, model_name: str, system: AgentSystem, **kwargs) -> OllamaModel:
+ """
+ Crée un agent de génération de texte et l'ajoute au système.
+
+ Args:
+ agent_id: Identifiant de l'agent
+ model_name: Nom du modèle Ollama à utiliser
+ system: Système d'agents auquel ajouter l'agent
+ **kwargs: Paramètres supplémentaires pour configurer le modèle
+
+ Returns:
+ L'instance du modèle créée
+ """
+ agent = TextGenerationModel(model_name, **kwargs)
+ system.add_agent(agent_id, agent)
+ return agent
+
+ def create_multimodal_agent(agent_id: str, model_name: str, system: AgentSystem, **kwargs) -> OllamaModel:
+ """
+ Crée un agent multimodal et l'ajoute au système.
+
+ Args:
+ agent_id: Identifiant de l'agent
+ model_name: Nom du modèle Ollama à utiliser
+ system: Système d'agents auquel ajouter l'agent
+ **kwargs: Paramètres supplémentaires pour configurer le modèle
+
+ Returns:
+ L'instance du modèle créée
+ """
+ agent = MultiModalModel(model_name, **kwargs)
+ system.add_agent(agent_id, agent)
+ return agent
+
+ def create_embedding_agent(agent_id: str, model_name: str, system: AgentSystem, **kwargs) -> OllamaModel:
+ """
+ Crée un agent d'embedding et l'ajoute au système.
+
+ Args:
+ agent_id: Identifiant de l'agent
+ model_name: Nom du modèle Ollama à utiliser
+ system: Système d'agents auquel ajouter l'agent
+ **kwargs: Paramètres supplémentaires pour configurer le modèle
+
+ Returns:
+ L'instance du modèle créée
+ """
+ agent = EmbeddingModel(model_name, **kwargs)
+ system.add_agent(agent_id, agent)
+ return agent
Maintenant, créons un fichier d'exemple pour montrer comment utiliser notre système d'agents :
super().__init__(model_name, **kwargs)
- def create_completion(self, prompt: str, max_tokens: int = None) -> str:
+ def create_completion(self, prompt: str, max_tokens: Optional[int] = None) -> str:
"""
Crée une complétion de texte simple.
Maintenant, créons un exemple pour montrer comment utiliser notre système d'agents :
-
+ """
+ Exemple d'utilisation du système d'agents Ollama.
+ Ce script montre comment configurer et utiliser différents types d'agents
+ basés sur les modèles Ollama disponibles sur votre serveur.
+ """
+
+ from ollama_models import (
+ AgentSystem,
+ create_text_agent,
+ create_multimodal_agent,
+ create_embedding_agent,
+ OllamaModel
+ )
+
+
+ def configurer_systeme_agents():
+ """Configure et retourne un système d'agents avec différents modèles."""
+
+ # Créer le système d'agents
+ system = AgentSystem()
+
+ # Ajouter un agent de génération de texte avec Llama 3.3
+ create_text_agent(
+ agent_id="assistant_texte",
+ model_name="llama3.3:70b-instruct-q8_0",
+ system=system,
+ temperature=0.7,
+ top_p=0.9,
+ num_ctx=4096,
+ stream=True
+ )
+
+ # Ajouter un agent spécialisé pour le code avec température basse
+ create_text_agent(
+ agent_id="assistant_code",
+ model_name="qwen2.5-coder:32b-instruct-fp16",
+ system=system,
+ temperature=0.2, # Température basse pour des réponses plus déterministes
+ top_p=0.8,
+ top_k=40,
+ num_ctx=8192, # Contexte plus large pour les tâches de code
+ stream=True
+ )
+
+ # Ajouter un agent multimodal pour l'analyse d'images
+ create_multimodal_agent(
+ agent_id="assistant_vision",
+ model_name="llama3.2-vision:90b-instruct-q8_0",
+ system=system,
+ temperature=0.8,
+ num_ctx=8192,
+ stream=False # Désactiver le streaming pour les modèles vision
+ )
+
+ # Ajouter un agent d'embedding
+ create_embedding_agent(
+ agent_id="agent_embedding",
+ model_name="nomic-embed-text:137m-v1.5-fp16",
+ system=system,
+ stream=False # Les embeddings ne nécessitent pas de streaming
+ )
+
+ return system
+
+
+ def exemple_generation_texte(system):
+ """Exemple d'utilisation d'un agent de génération de texte."""
+
+ print("\n=== EXEMPLE GÉNÉRATION DE TEXTE ===")
+
+ # Récupérer l'agent
+ agent = system.get_agent("assistant_texte")
+
+ if agent:
+ # Générer du texte
+ prompt = "Explique-moi les avantages des architectures basées sur les transformers en IA."
+ print(f"Demande: {prompt}")
+ print("\nRéponse:")
+
+ # Utiliser l'API de génération
+ agent.generate(prompt)
+ else:
+ print("Agent 'assistant_texte' non trouvé.")
+
+
+ def exemple_generation_code(system):
+ """Exemple d'utilisation d'un agent spécialisé pour le code."""
+
+ print("\n=== EXEMPLE GÉNÉRATION DE CODE ===")
+
+ # Récupérer l'agent
+ agent = system.get_agent("assistant_code")
+
+ if agent:
+ # Modifier temporairement certains paramètres pour cette requête
+ agent.update_options(temperature=0.1, num_predict=500)
+
+ # Générer du code
+ prompt = "Écris une fonction Python pour calculer le nombre de Fibonacci de manière récursive avec mémoïsation."
+ print(f"Demande: {prompt}")
+ print("\nRéponse:")
+
+ # Utiliser l'API de génération
+ agent.generate(prompt)
+
+ # Remettre les paramètres par défaut
+ agent.update_options(temperature=0.2, num_predict=128)
+ else:
+ print("Agent 'assistant_code' non trouvé.")
+
+
+ def exemple_chat(system):
+ """Exemple d'utilisation de l'API chat."""
+
+ print("\n=== EXEMPLE CHAT ===")
+
+ # Récupérer l'agent
+ agent = system.get_agent("assistant_texte")
+
+ if agent:
+ # Créer une conversation
+ messages = [
+ {"role": "system", "content": "Tu es un assistant IA serviable, concis et précis."},
+ {"role": "user", "content": "Quels sont les 3 principaux avantages des modèles Ollama par rapport aux API cloud?"}
+ ]
+
+ print("Conversation:")
+ for msg in messages:
+ print(f"{msg['role']}: {msg['content']}")
+
+ print("\nRéponse:")
+
+ # Utiliser l'API chat
+ response = agent.chat(messages)
+
+ # Ajouter la réponse à l'historique
+ if isinstance(response, str):
+ messages.append({"role": "assistant", "content": response})
+ elif isinstance(response, dict) and "message" in response and "content" in response["message"]:
+ messages.append({"role": "assistant", "content": response["message"]["content"]})
+
+ # Continuer la conversation
+ messages.append({"role": "user", "content": "Et quels sont les inconvénients?"})
+
+ print("\nUtilisateur: Et quels sont les inconvénients?")
+ print("\nRéponse:")
+
+ # Continuer avec l'API chat
+ agent.chat(messages)
+ else:
+ print("Agent 'assistant_texte' non trouvé.")
+
+
+ def exemple_embeddings(system):
+ """Exemple d'utilisation de l'agent d'embedding."""
+
+ print("\n=== EXEMPLE EMBEDDINGS ===")
+
+ # Récupérer l'agent
+ agent = system.get_agent("agent_embedding")
+
+ if agent:
+ # Textes à encoder
+ textes = [
+ "Les modèles de langage sont très utiles pour l'IA moderne.",
+ "Les embeddings permettent de représenter du texte en vecteurs numériques."
+ ]
+
+ print("Génération d'embeddings pour les textes suivants:")
+ for i, texte in enumerate(textes):
+ print(f"{i+1}. {texte}")
+
+ # Obtenir les embeddings
+ embeddings = agent.get_embeddings(textes)
+
+ # Afficher les dimensions des embeddings
+ if embeddings:
+ print(f"\nEmbeddings générés avec succès!")
+ print(f"Nombre d'embeddings: {len(embeddings)}")
+ print(f"Dimension de chaque embedding: {len(embeddings[0])}")
+ print(f"Premiers éléments du premier embedding: {embeddings[0][:5]}...")
+ else:
+ print("Échec de la génération des embeddings.")
+ else:
+ print("Agent 'agent_embedding' non trouvé.")
+
+
+ def exemple_vision(system):
+ """Exemple d'utilisation de l'agent de vision (nécessite un fichier image)."""
+
+ print("\n=== EXEMPLE VISION (NÉCESSITE UNE IMAGE) ===")
+
+ # Récupérer l'agent
+ agent = system.get_agent("assistant_vision")
+
+ if agent:
+ print("Pour tester l'agent de vision, vous devez fournir un chemin vers une image.")
+ print("Exemple d'utilisation:")
+ print("```python")
+ print("image_path = 'chemin/vers/votre/image.jpg'")
+ print("prompt = 'Décris cette image en détail.'")
+ print("response = agent.analyze_image(prompt, image_path)")
+ print("```")
+ else:
+ print("Agent 'assistant_vision' non trouvé.")
+
+
+ def afficher_modeles_disponibles():
+ """Affiche la liste des modèles Ollama disponibles."""
+
+ print("\n=== MODÈLES OLLAMA DISPONIBLES ===")
+
+ # Obtenir la liste des modèles
+ models = OllamaModel.list_models()
+
+ if "error" in models:
+ print(f"Erreur lors de la récupération des modèles: {models['error']}")
+ return
+
+ # Afficher les modèles
+ if "models" in models:
+ for i, model in enumerate(models["models"]):
+ print(f"{i+1}. {model['name']} ({model['size']})")
+ else:
+ print("Aucun modèle trouvé ou format de réponse inattendu.")
+
+
+ def main():
+ """Fonction principale."""
+
+ print("=== SYSTÈME D'AGENTS OLLAMA ===")
+
+ # Afficher les modèles disponibles
+ afficher_modeles_disponibles()
+
+ # Configurer le système d'agents
+ system = configurer_systeme_agents()
+
+ # Lister les agents configurés
+ agents = system.list_agents()
+ print("\n=== AGENTS CONFIGURÉS ===")
+ for agent_id, model_name in agents.items():
+ print(f"Agent: {agent_id}, Modèle: {model_name}")
+
+ # Exemples d'utilisation
+ try:
+ exemple_generation_texte(system)
+ exemple_generation_code(system)
+ exemple_chat(system)
+ exemple_embeddings(system)
+ exemple_vision(system)
+ except Exception as e:
+ print(f"\nUne erreur s'est produite: {str(e)}")
+
+ print("\n=== FIN DES EXEMPLES ===")
+
+
+ if __name__ == "__main__":
+ main()
Maintenant, créons un fichier README pour documenter le projet :
-
+ # 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)
Créons enfin un fichier requirements.txt pour faciliter l'installation des dépendances :
-
+ requests>=2.31.0
ls -la AIagent/src/
fgras-ca@PC-DEV:~/AI_agent$ ls -la AIagent/src/
total 36
drwxr-xr-x 2 fgras-ca fgras-ca 4096 Mar 20 17:08 .
drwxr-xr-x 6 fgras-ca fgras-ca 4096 Mar 20 17:09 ..
-rw-r--r-- 1 fgras-ca fgras-ca 8264 Mar 20 17:09 exemple_usage.py
-rw-r--r-- 1 fgras-ca fgras-ca 14611 Mar 20 17:08 ollama_models.py
fgras-ca@PC-DEV:~/AI_agent$
ls -la AIagent
fgras-ca@PC-DEV:~/AI_agent$ ls -la AIagent
total 40
drwxr-xr-x 6 fgras-ca fgras-ca 4096 Mar 20 17:09 .
drwxr-xr-x 4 fgras-ca fgras-ca 4096 Mar 20 17:07 ..
-rw-r--r-- 1 fgras-ca fgras-ca 4583 Mar 20 17:09 README.md
drwxr-xr-x 2 fgras-ca fgras-ca 4096 Mar 20 16:57 bin
drwxr-xr-x 3 fgras-ca fgras-ca 4096 Mar 20 16:57 include
drwxr-xr-x 3 fgras-ca fgras-ca 4096 Mar 20 16:57 lib
lrwxrwxrwx 1 fgras-ca fgras-ca 3 Mar 20 16:57 lib64 -> lib
-rw-r--r-- 1 fgras-ca fgras-ca 170 Mar 20 16:57 pyvenv.cfg
-rw-r--r-- 1 fgras-ca fgras-ca 17 Mar 20 17:09 requirements.txt
drwxr-xr-x 2 fgras-ca fgras-ca 4096 Mar 20 17:08 src
fgras-ca@PC-DEV:~/AI_agent$
Voilà ! J'ai créé un système complet d'agents Ollama pour vous. Voici un résumé de ce que j'ai fait :
-
J'ai développé une architecture de classes pour interagir avec les modèles Ollama :
OllamaModel: Classe de base avec les fonctionnalités communesTextGenerationModel: Pour la génération de texte et de codeMultiModalModel: Pour les modèles qui supportent les images (vision)EmbeddingModel: Pour générer des embeddings de texteAgentSystem: Pour gérer plusieurs agents
-
Fonctionnalités principales :
- Génération de texte avec paramètres ajustables (température, top_p, top_k, etc.)
- Support du mode chat pour les conversations
- Analyse d'images avec les modèles multimodaux
- Génération d'embeddings
- Streaming des réponses pour une expérience utilisateur améliorée
-
Documentation et exemples :
- Un README détaillé expliquant comment utiliser le système
- Un script d'exemple montrant l'utilisation des différentes fonctionnalités
- Des commentaires complets dans le code
Pour utiliser ce système, vous pouvez :
- S'assurer qu'Ollama est en cours d'exécution sur votre serveur
- Installer la dépendance requise :
pip install -r AIagent/requirements.txt - Exécuter l'exemple :
python AIagent/src/exemple_usage.py
Vous pouvez également personnaliser le système en ajoutant de nouvelles classes spécialisées ou en étendant les fonctionnalités existantes selon vos besoins.
User
For the code present, we get this error:
Cannot access attribute "txt" for class "Response"
Attribute "txt" is unknown
How can I resolve this? If you propose a fix, please make it concise.
Assistant
Je vois l'erreur. L'attribut correct est text et non txt. Je vais corriger cela :
#Adresse du serveur ollama
response = requests.post("http://217.182.105.173:11434/api/generate", json=parameters)
- result = response.json()["response"] if response.ok else f"Erreur: {response.txt}"
+ result = response.json()["response"] if response.ok else f"Erreur: {response.text}"
#enregistrement
L'erreur est maintenant corrigée. L'attribut text est la propriété correcte pour accéder au contenu textuel d'une réponse HTTP dans la bibliothèque requests.
User
For the code present, we get this error:
Expression with type "tuple[int, str]" cannot be assigned to target tuple
Type "tuple[int, str]" is incompatible with target tuple
Tuple size mismatch; expected 1 but received 2
How can I resolve this? If you propose a fix, please make it concise.
Assistant
L'erreur provient de la syntaxe de la boucle for. Vous devez utiliser un seul nom de variable pour l'index. Voici la correction :
Remplacez cette ligne :
for i, in enumerate(varying_keys):
par :
for i, key in enumerate(varying_keys):
Cela résoudra l'erreur en assignant correctement la clé à la variable key.