Ok ora voglio che mi spieghi in maniera semplice ma dettagliata come usare agent verse,…
- User
Ok ora voglio che mi spieghi in maniera semplice ma dettagliata come usare agent verse, voglio anche un esempio di 1 agent che posso usare da terminale e che interagisce con il terminale linux
Assistant
Guida Semplice ad AgentVerse
AgentVerse è un framework che ti permette di creare e orchestrare agenti AI che possono collaborare tra loro. Ecco come configurarlo e usarlo per creare un agente che interagisce con il terminale Linux.
Parte 1: Installazione e Setup
-
Installa AgentVerse (assicurati di avere Python 3.9+ installato):
# Crea un ambiente virtuale (opzionale ma consigliato) python -m venv agentverse-env source agentverse-env/bin/activate # Installa AgentVerse pip install agentverse -
Installa Ollama (se non l'hai già fatto):
curl https://ollama.ai/install.sh | sh ollama serve & ollama pull whiterabbit-neo
Parte 2: Crea un Agente per il Terminale Linux
Creiamo un file Python chiamato
terminal_agent.pyche definisce un agente in grado di interagire con il terminale Linux:from agentverse.agents import Agent from agentverse.agents.base import BaseAgent from agentverse.llms import LLM from agentverse.llms.ollama import Ollama from agentverse.tools import Tool from typing import List, Dict, Any import subprocess import os # Definisci uno strumento per eseguire comandi shell class TerminalTool(Tool): name = "terminal" description = "Esegue comandi shell sul sistema Linux" def run(self, command: str) -> str: """Esegue un comando shell e restituisce l'output""" try: result = subprocess.run( command, shell=True, capture_output=True, text=True, timeout=30 # Timeout di 30 secondi ) return f"STDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}" except Exception as e: return f"Errore nell'esecuzione del comando: {str(e)}" # Definisci uno strumento per leggere file class FileReadTool(Tool): name = "read_file" description = "Legge il contenuto di un file" def run(self, filepath: str) -> str: """Legge un file e restituisce il contenuto""" try: with open(filepath, 'r') as f: return f.read() except Exception as e: return f"Errore nella lettura del file: {str(e)}" # Definisci uno strumento per scrivere file class FileWriteTool(Tool): name = "write_file" description = "Scrive contenuto in un file" def run(self, filepath: str, content: str) -> str: """Scrive contenuto in un file""" try: with open(filepath, 'w') as f: f.write(content) return f"File {filepath} scritto con successo" except Exception as e: return f"Errore nella scrittura del file: {str(e)}" # Definisci l'agente del terminale class TerminalAgent(BaseAgent): def __init__(self, name: str, llm: LLM, tools: List[Tool]): super().__init__(name=name, llm=llm) self.tools = tools # Prompt di sistema per l'agente self.system_prompt = """ Sei un assistente Linux esperto che aiuta l'utente a interagire con il sistema. Puoi eseguire comandi shell, leggere e scrivere file. Quando ti viene chiesto di eseguire un'azione: 1. Decidi quale strumento utilizzare 2. Esegui lo strumento con i parametri appropriati 3. Analizza il risultato e fornisci una risposta utile Strumenti disponibili: - terminal: esegue comandi shell - read_file: legge il contenuto di un file - write_file: scrive contenuto in un file Esempi: - Per eseguire un comando: usa terminal("ls -la") - Per leggere un file: usa read_file("/path/to/file") - Per scrivere un file: usa write_file("/path/to/file", "contenuto") Sii preciso e attento. Non eseguire comandi potenzialmente dannosi. """ def run(self, user_input: str) -> str: """Elabora l'input dell'utente e restituisce una risposta""" # Costruisci il prompt per il LLM prompt = f"{self.system_prompt}\n\nInput utente: {user_input}\n\nRisposta:" # Ottieni la risposta dal LLM response = self.llm.generate(prompt) # Analizza la risposta per identificare i comandi degli strumenti # Questo è un parser semplificato, in un'implementazione reale dovresti usare regex o parser più robusti if "terminal(" in response: # Estrai il comando tra parentesi command = response.split("terminal(")[1].split(")")[0].strip('"\'') result = self.tools[0].run(command) return f"Ho eseguito: {command}\n\nRisultato:\n{result}" elif "read_file(" in response: filepath = response.split("read_file(")[1].split(")")[0].strip('"\'') result = self.tools[1].run(filepath) return f"Ho letto il file: {filepath}\n\nContenuto:\n{result}" elif "write_file(" in response: parts = response.split("write_file(")[1].split(")")[0].split(",", 1) filepath = parts[0].strip('"\'') content = parts[1].strip().strip('"\'') result = self.tools[2].run(filepath, content) return f"Ho scritto nel file: {filepath}\n\nRisultato:\n{result}" # Se non viene rilevato alcun comando di strumento, restituisci la risposta originale return response # Funzione principale per eseguire l'agente def main(): # Inizializza il modello LLM (Ollama con WhiteRabbit-Neo) llm = Ollama(model="whiterabbit-neo") # Inizializza gli strumenti tools = [ TerminalTool(), FileReadTool(), FileWriteTool() ] # Crea l'agente agent = TerminalAgent(name="LinuxAssistant", llm=llm, tools=tools) print("🤖 Terminal Agent attivo! (Digita 'exit' per uscire)") print("Esempi di comandi:") print("- Mostra i file nella directory corrente") print("- Crea un file chiamato test.txt con il contenuto 'Hello World'") print("- Controlla lo stato della rete") # Loop principale while True: user_input = input("\n🧑💻 > ") if user_input.lower() in ["exit", "quit", "q"]: break # Esegui l'agente e stampa la risposta response = agent.run(user_input) print(f"\n🤖 {response}") if __name__ == "__main__": main()Parte 3: Esecuzione dell'Agente
-
Salva il file
terminal_agent.py -
Esegui l'agente:
python terminal_agent.py -
Interagisci con l'agente:
- "Mostra i file nella directory corrente"
- "Crea un file chiamato test.txt con il contenuto 'Hello World'"
- "Leggi il contenuto del file test.txt"
- "Mostrami le informazioni di sistema"
- "Controlla lo stato della rete"
Parte 4: Spiegazione del Codice
-
Strumenti (Tools):
TerminalTool: Esegue comandi shell usandosubprocessFileReadTool: Legge il contenuto dei fileFileWriteTool: Scrive contenuto nei file
-
Agente (TerminalAgent):
- Utilizza un prompt di sistema che spiega come usare gli strumenti
- Analizza la risposta del LLM per identificare i comandi degli strumenti
- Esegue gli strumenti appropriati e restituisce i risultati
-
Loop Principale:
- Accetta input dall'utente
- Passa l'input all'agente
- Mostra la risposta dell'agente
Parte 5: Personalizzazione
Puoi facilmente estendere questo agente:
-
Aggiungi nuovi strumenti:
class NetworkScanTool(Tool): name = "network_scan" description = "Esegue una scansione di rete" def run(self, target: str) -> str: command = f"nmap -sV {target}" result = subprocess.run(command, shell=True, capture_output=True, text=True) return result.stdout -
Migliora il parser delle risposte:
- Usa espressioni regolari per un'analisi più robusta
- Implementa un parser JSON per strutturare meglio le risposte
-
Aggiungi memoria:
- Mantieni uno storico delle conversazioni
- Implementa un contesto persistente
Parte 6: Considerazioni di Sicurezza
⚠️ Importante: Questo agente può eseguire qualsiasi comando shell, quindi:
- Eseguilo in un ambiente sandbox (VM o container)
- Limita i permessi dell'utente che esegue lo script
- Aggiungi una lista di comandi proibiti per maggiore sicurezza:
FORBIDDEN_COMMANDS = ["rm -rf", "mkfs", "dd if=/dev/zero", ":(){ :|:& };:"] def is_safe_command(command): for forbidden in FORBIDDEN_COMMANDS: if forbidden in command: return False return True
Esempio di Sessione
🤖 Terminal Agent attivo! (Digita 'exit' per uscire) Esempi di comandi: - Mostra i file nella directory corrente - Crea un file chiamato test.txt con il contenuto 'Hello World' - Controlla lo stato della rete 🧑💻 > Mostra i file nella directory corrente 🤖 Ho eseguito: ls -la Risultato: STDOUT: total 24 drwxr-xr-x 3 user user 4096 May 14 10:23 . drwxr-xr-x 15 user user 4096 May 14 10:20 .. -rw-r--r-- 1 user user 5432 May 14 10:23 terminal_agent.py drwxr-xr-x 2 user user 4096 May 14 10:21 agentverse-env STDERR: 🧑💻 > Crea un file chiamato test.txt con il contenuto 'Hello World' 🤖 Ho scritto nel file: test.txt Risultato: File test.txt scritto con successo 🧑💻 > Leggi il contenuto del file test.txt 🤖 Ho letto il file: test.txt Contenuto: Hello World 🧑💻 > exitQuesto è un esempio semplice ma funzionale di come usare AgentVerse per creare un agente che interagisce con il terminale Linux. Puoi espanderlo e personalizzarlo in base alle tue esigenze!
-
- User
ci sono alternative ad Agent Verse che usano sempre una struttura con yaml per definire i ruoli e compiti dell'agente e che permetta il multi agent?
Assistant
Alternative ad AgentVerse con Configurazione YAML e Supporto Multi-Agente
Sì, esistono diverse alternative ad AgentVerse che utilizzano file YAML per definire ruoli e compiti degli agenti e supportano architetture multi-agente. Ecco le principali opzioni:
1. CrewAI
CrewAI è probabilmente l'alternativa più diretta ad AgentVerse con supporto YAML.
Caratteristiche principali:
- Configurazione basata su YAML per definire "crew" (squadre) di agenti
- Supporto nativo per multi-agente con ruoli e compiti ben definiti
- Integrazione con Ollama e modelli locali
- Strumenti per interagire con il terminale Linux
Esempio di configurazione YAML:
# crew_config.yaml name: "Linux Admin Team" description: "Team di agenti per amministrare sistemi Linux" agents: - name: "CommandExecutor" role: "Esegue comandi shell e interpreta i risultati" goal: "Eseguire comandi shell in modo sicuro ed efficiente" backstory: "Esperto di sistemi Linux con anni di esperienza" tools: - name: "terminal" description: "Esegue comandi shell" - name: "file_reader" description: "Legge file dal filesystem" - name: "SecurityAnalyst" role: "Analizza la sicurezza del sistema" goal: "Identificare e risolvere problemi di sicurezza" backstory: "Specialista in cybersecurity con esperienza in Kali Linux" tools: - name: "vulnerability_scanner" description: "Esegue scansioni di vulnerabilità" tasks: - name: "system_check" description: "Controlla lo stato del sistema" agent: "CommandExecutor" expected_output: "Rapporto sullo stato del sistema" - name: "security_audit" description: "Esegue un audit di sicurezza" agent: "SecurityAnalyst" expected_output: "Rapporto di sicurezza"Esempio di codice Python per usare CrewAI:
from crewai import Crew, Agent, Task, Tool from crewai.tools import ShellTool import yaml # Carica la configurazione YAML with open('crew_config.yaml', 'r') as file: config = yaml.safe_load(file) # Crea gli strumenti shell_tool = ShellTool() # Crea gli agenti agents = [] for agent_config in config['agents']: agent = Agent( name=agent_config['name'], role=agent_config['role'], goal=agent_config['goal'], backstory=agent_config['backstory'], llm="ollama/whiterabbit-neo", # Usa il modello locale tools=[shell_tool] ) agents.append(agent) # Crea i task tasks = [] for task_config in config['tasks']: agent = next(a for a in agents if a.name == task_config['agent']) task = Task( description=task_config['description'], expected_output=task_config['expected_output'], agent=agent ) tasks.append(task) # Crea la crew crew = Crew( agents=agents, tasks=tasks, verbose=True ) # Esegui la crew result = crew.kickoff() print(result)2. AutoGen
AutoGen di Microsoft è un framework potente per la creazione di agenti conversazionali che collaborano tra loro.
Caratteristiche principali:
- Supporto per configurazione YAML
- Architettura multi-agente avanzata
- Integrazione con modelli locali (incluso Ollama)
- Strumenti per interagire con il sistema operativo
Esempio di configurazione YAML:
# autogen_config.yaml agents: user_proxy: type: "UserProxyAgent" name: "User" human_input_mode: "TERMINATE" code_execution_config: executor: "local" allow_code_execution: true terminal_expert: type: "AssistantAgent" name: "TerminalExpert" llm_config: model: "ollama/whiterabbit-neo" base_url: "http://localhost:11434/v1" system_message: | Sei un esperto di terminale Linux. Aiuti l'utente a eseguire comandi shell. Quando necessario, genera codice Python o comandi Bash per risolvere problemi. security_expert: type: "AssistantAgent" name: "SecurityExpert" llm_config: model: "ollama/whiterabbit-neo" base_url: "http://localhost:11434/v1" system_message: | Sei un esperto di sicurezza informatica. Aiuti a identificare e risolvere problemi di sicurezza. workflows: terminal_workflow: agents: ["user_proxy", "terminal_expert"] initial_message: "Come posso aiutarti con il terminale Linux oggi?" security_workflow: agents: ["user_proxy", "security_expert"] initial_message: "Come posso aiutarti con la sicurezza del sistema oggi?"Esempio di codice Python per usare AutoGen:
import autogen import yaml # Carica la configurazione YAML with open('autogen_config.yaml', 'r') as file: config = yaml.safe_load(file) # Crea gli agenti agents = {} for agent_name, agent_config in config['agents'].items(): if agent_config['type'] == 'UserProxyAgent': agents[agent_name] = autogen.UserProxyAgent( name=agent_config['name'], human_input_mode=agent_config['human_input_mode'], code_execution_config=agent_config.get('code_execution_config') ) elif agent_config['type'] == 'AssistantAgent': agents[agent_name] = autogen.AssistantAgent( name=agent_config['name'], llm_config=agent_config['llm_config'], system_message=agent_config['system_message'] ) # Esegui il workflow workflow_name = input("Quale workflow vuoi eseguire? (terminal_workflow/security_workflow): ") workflow = config['workflows'][workflow_name] agent_list = [agents[agent_name] for agent_name in workflow['agents']] # Avvia la conversazione initial_agent = agent_list[0] target_agent = agent_list[1] initial_agent.initiate_chat(target_agent, message=workflow['initial_message'])3. MetaGPT
MetaGPT è un framework che permette di definire "società di agenti" che collaborano per risolvere problemi complessi.
Caratteristiche principali:
- Configurazione basata su YAML
- Supporto per ruoli e workflow multi-agente
- Integrazione con modelli locali
- Strumenti per interagire con il sistema
Esempio di configurazione YAML:
# metagpt_config.yaml name: "Linux Admin Team" description: "Team di agenti per amministrare sistemi Linux" roles: - name: "SystemAdmin" profile: "Esperto di sistemi Linux" goal: "Gestire e ottimizzare sistemi Linux" constraints: "Non eseguire comandi potenzialmente dannosi" actions: - "ExecuteCommand" - "ReadFile" - "WriteFile" - name: "SecurityExpert" profile: "Specialista in sicurezza informatica" goal: "Garantire la sicurezza del sistema" constraints: "Rispettare la privacy e le normative" actions: - "ScanVulnerabilities" - "AnalyzeLog" actions: - name: "ExecuteCommand" description: "Esegue un comando shell" args: - name: "command" type: "string" description: "Il comando da eseguire" - name: "ReadFile" description: "Legge un file" args: - name: "path" type: "string" description: "Il percorso del file da leggere" - name: "WriteFile" description: "Scrive in un file" args: - name: "path" type: "string" description: "Il percorso del file da scrivere" - name: "content" type: "string" description: "Il contenuto da scrivere nel file"4. Langroid
Langroid è un framework più recente ma promettente per la creazione di agenti AI.
Caratteristiche principali:
- Configurazione basata su YAML
- Supporto per multi-agente
- Integrazione con modelli locali
- Strumenti per interagire con il sistema
Esempio di configurazione YAML:
# langroid_config.yaml agents: terminal_agent: name: "TerminalAgent" llm: provider: "ollama" model: "whiterabbit-neo" base_url: "http://localhost:11434/v1" tools: - name: "shell" description: "Esegue comandi shell" - name: "file_read" description: "Legge file dal filesystem" - name: "file_write" description: "Scrive file nel filesystem" system_prompt: | Sei un assistente Linux esperto che aiuta l'utente a interagire con il sistema. Puoi eseguire comandi shell, leggere e scrivere file. security_agent: name: "SecurityAgent" llm: provider: "ollama" model: "whiterabbit-neo" base_url: "http://localhost:11434/v1" tools: - name: "vulnerability_scan" description: "Esegue scansioni di vulnerabilità" - name: "log_analysis" description: "Analizza i log di sistema" system_prompt: | Sei un esperto di sicurezza informatica che aiuta a identificare e risolvere problemi di sicurezza.Tabella Comparativa
Framework Configurazione YAML Multi-Agente Integrazione Ollama Interazione Terminale Curva di Apprendimento Maturità CrewAI ✅ Nativa ✅ Eccellente ✅ Diretta ✅ ShellTool integrato 🟢 Bassa 🟡 Media AutoGen ✅ Supportata ✅ Avanzata ✅ Via API ✅ Code Execution 🟠 Media 🟢 Alta MetaGPT ✅ Nativa ✅ Complessa ✅ Via API ✅ Custom Actions 🔴 Alta 🟡 Media Langroid ✅ Supportata ✅ Buona ✅ Via API ✅ Custom Tools 🟡 Media-Bassa 🔴 Bassa Esempio Pratico: CrewAI con Terminale Linux
Ecco un esempio completo di come usare CrewAI per creare un agente che interagisce con il terminale Linux:
from crewai import Agent, Task, Crew, Process from crewai.tools import ShellTool import yaml # Definisci lo strumento per il terminale shell_tool = ShellTool() # Carica la configurazione YAML with open('linux_crew.yaml', 'r') as file: config = yaml.safe_load(file) # Crea l'agente del terminale terminal_agent = Agent( name="TerminalExpert", role="Esperto di terminale Linux", goal="Aiutare l'utente a interagire con il sistema Linux", backstory="Hai anni di esperienza nell'amministrazione di sistemi Linux", verbose=True, llm="ollama/whiterabbit-neo", tools=[shell_tool] ) # Crea il task terminal_task = Task( description="Esegui il comando richiesto dall'utente e spiega il risultato", expected_output="Risultato del comando e spiegazione", agent=terminal_agent ) # Crea la crew linux_crew = Crew( agents=[terminal_agent], tasks=[terminal_task], verbose=True, process=Process.sequential ) # Funzione per interagire con l'agente def interact_with_agent(): print("🤖 Terminal Agent attivo! (Digita 'exit' per uscire)") print("Esempi di comandi:") print("- Mostra i file nella directory corrente") print("- Crea un file chiamato test.txt con il contenuto 'Hello World'") print("- Controlla lo stato della rete") while True: user_input = input("\n🧑💻 > ") if user_input.lower() in ["exit", "quit", "q"]: break # Modifica il task con l'input dell'utente terminal_task.description = f"Esegui questo comando o richiesta: {user_input}" # Esegui la crew result = linux_crew.kickoff() print(f"\n🤖 {result}") if __name__ == "__main__": interact_with_agent()Con il file YAML corrispondente:
# linux_crew.yaml name: "Linux Admin Crew" description: "Crew di agenti per amministrare sistemi Linux" agents: - name: "TerminalExpert" role: "Esperto di terminale Linux" goal: "Aiutare l'utente a interagire con il sistema Linux" backstory: "Hai anni di esperienza nell'amministrazione di sistemi Linux" tasks: - description: "Esegui il comando richiesto dall'utente e spiega il risultato" expected_output: "Risultato del comando e spiegazione" agent: "TerminalExpert"Conclusione
Se stai cercando un'alternativa ad AgentVerse con configurazione YAML e supporto multi-agente, CrewAI è probabilmente la scelta migliore per iniziare, grazie alla sua semplicità e al supporto nativo per YAML e multi-agente. AutoGen è un'ottima scelta se hai bisogno di funzionalità più avanzate e una maggiore flessibilità.
Tutte queste opzioni possono essere integrate con Ollama e modelli locali come WhiteRabbit-Neo, e tutte supportano l'interazione con il terminale Linux attraverso vari strumenti e meccanismi.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.