Agents IA et orchestration

Section 13.6.5 : Agents IA et orchestration

🎯 Objectif pédagogique

Comprendre les agents IA autonomes, l'orchestration multi-agents, et implémenter un agent capable d'utiliser des outils (function calling) pour accomplir des tâches complexes.

Qu'est-ce qu'un agent IA ?

Un agent IA est un système qui utilise un LLM pour raisonner, planifier, et agir de manière autonome. Contrairement à un simple chatbot qui répond, un agent peut utiliser des outils, consulter des bases de données, et exécuter des actions.

Function Calling (Tool Use)

Le function calling permet au LLM d'appeler des fonctions que vous définissez :

# Définir les outils disponibles
TOOLS = [
  {
    type: 'function',
    function: {
      name: 'search_products',
      description: 'Recherche des produits dans le catalogue',
      parameters: {
        type: 'object',
        properties: {
          query: { type: 'string', description: 'Termes de recherche' },
          category: { type: 'string', description: 'Catégorie de produit' },
          max_price: { type: 'number', description: 'Prix maximum' }
        },
        required: ['query']
      }
    }
  },
  {
    type: 'function',
    function: {
      name: 'get_order_status',
      description: 'Vérifie le statut d une commande',
      parameters: {
        type: 'object',
        properties: {
          order_id: { type: 'string', description: 'ID de la commande' }
        },
        required: ['order_id']
      }
    }
  }
]

Implémentation d'un agent

# app/services/agent_service.rb

class AgentService
  MAX_ITERATIONS = 10

  def initialize(tools:)
    @tools = tools
    @messages = []
  end

  def run(user_message)
    @messages << { role: 'user', content: user_message }

    MAX_ITERATIONS.times do
      response = OPENAI_CLIENT.chat(
        parameters: {
          model: 'gpt-4',
          messages: @messages,
          tools: @tools,
          tool_choice: 'auto'
        }
      )

      message = response.dig('choices', 0, 'message')
      @messages << message

      # Si le LLM veut appeler un outil
      if message['tool_calls']
        message['tool_calls'].each do |tool_call|
          result = execute_tool(
            tool_call['function']['name'],
            JSON.parse(tool_call['function']['arguments'])
          )

          @messages << {
            role: 'tool',
            tool_call_id: tool_call['id'],
            content: result.to_json
          }
        end
      else
        # Réponse finale
        return message['content']
      end
    end

    'Agent a atteint la limite d itérations.'
  end

  private

  def execute_tool(name, args)
    case name
    when 'search_products'
      Product.search(args['query'])
             .where(category: args['category'])
             .where('price <= ?', args['max_price'])
             .limit(5)
             .map { |p| { name: p.name, price: p.price } }
    when 'get_order_status'
      order = Order.find_by(id: args['order_id'])
      order ? { status: order.status, eta: order.eta } : { error: 'Commande non trouvée' }
    end
  end
end

# Utilisation
agent = AgentService.new(tools: TOOLS)
response = agent.run(
  "Je cherche des chaussures de running sous 100€, "  \
  "et aussi le statut de ma commande #12345"
)

Orchestration multi-agents

Pour des tâches complexes, plusieurs agents spécialisés collaborent :

# Agent de routage (dispatcher)
class DispatcherAgent
  AGENTS = {
    'sales' => SalesAgent,
    'support' => SupportAgent,
    'analytics' => AnalyticsAgent
  }

  def route(message)
    # Le LLM détermine quel agent doit traiter
    category = AiService.chat(
      "Classifie ce message en une catégorie : sales, support, analytics.\n" \
      "Message : #{message}\n" \
      "Réponds uniquement par la catégorie.",
      system_message: 'Tu es un routeur de messages.'
    ).strip.downcase

    agent_class = AGENTS[category]
    agent_class.new.handle(message)
  end
end