Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219· AnthropicHugging Face LMArena Human Preference 140K

Ok ora voglio che mi spieghi in maniera semplice ma dettagliata come usare agent verse,…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with chatgpt-4o-latest-20250326’s answer.
  1. 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

  2. Claude 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

    1. 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
      
    2. 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.py che 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

    1. Salva il file terminal_agent.py

    2. Esegui l'agente:

      python terminal_agent.py
      
    3. 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

    1. Strumenti (Tools):

      • TerminalTool: Esegue comandi shell usando subprocess
      • FileReadTool: Legge il contenuto dei file
      • FileWriteTool: Scrive contenuto nei file
    2. 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
    3. Loop Principale:

      • Accetta input dall'utente
      • Passa l'input all'agente
      • Mostra la risposta dell'agente

    Parte 5: Personalizzazione

    Puoi facilmente estendere questo agente:

    1. 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
      
    2. Migliora il parser delle risposte:

      • Usa espressioni regolari per un'analisi più robusta
      • Implementa un parser JSON per strutturare meglio le risposte
    3. 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:

    1. Eseguilo in un ambiente sandbox (VM o container)
    2. Limita i permessi dell'utente che esegue lo script
    3. 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
    
    🧑‍💻 > exit
    

    Questo è 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!

  3. 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?

  4. Claude 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

    FrameworkConfigurazione YAMLMulti-AgenteIntegrazione OllamaInterazione TerminaleCurva di ApprendimentoMaturità
    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.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.