Gemma 4 en production : guide pratique d'intégration dans une stack PHP/Symfony

Google vient de publier Gemma 4, sa famille de modèles open source la plus capable à ce jour, accompagnée pour la première fois d'une licence Apache 2.0 pleinement permissive. C'est une opportunité concrète pour les équipes PHP/Symfony de self-héberger un LLM performant sans dépendre d'une API tierce payante ni sacrifier la confidentialité des données. Cet article vous propose une checklist structurée pour passer de zéro à un agent fonctionnel en production.

Source originale : The Decoder – Google's Gemma 4 is now available with Apache 2.0 licensing

1. Choisir la bonne taille de modèle selon vos contraintes hardware

Gemma 4 se décline en quatre variantes. Le bon choix dépend directement de votre infrastructure :

Recommandations pratiques :

• Développement local / CI : démarrez avec E2B ou E4B. Un Mac M2 avec 16 Go de RAM suffira.
• API interne à faible charge : le modèle 26B quantisé en Q4_K_M sur une RTX 3090 offre un bon compromis qualité/coût.
• Workflows agentiques ou RAG exigeants : visez le 31B avec quantization Q5_K_M pour conserver la précision sur les tâches de raisonnement multi-étapes.

Quantization : les formats à retenir

Via llama.cpp ou Ollama, les formats GGUF permettent de réduire significativement l'empreinte mémoire :

• Q4_K_M : réduction ~60% de la VRAM, légère perte de qualité, idéal pour les petits serveurs.
• Q5_K_M : équilibre recommandé pour les agents en production.
• Q8_0 : quasi-précision FP16, pour les serveurs bien équipés.

# Exemple : lancer Gemma 4 26B quantisé avec Ollama
ollama run gemma4:26b-q5_k_m

2. Packaging Docker et déploiement Kubernetes

Pour intégrer Gemma 4 dans votre infrastructure existante, la bonne pratique est d'exposer le modèle comme un service HTTP indépendant, consommé par votre application Symfony via un client HTTP standard.

Dockerfile pour Ollama + Gemma 4

FROM ollama/ollama:latest

# Pré-charger le modèle dans l'image (optionnel, alourdit l'image)
RUN ollama serve & sleep 5 && ollama pull gemma4:4b-q5_k_m

EXPOSE 11434
CMD ["ollama", "serve"]

Manifest Kubernetes minimal

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gemma4-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma4
  template:
    metadata:
      labels:
        app: gemma4
    spec:
      containers:
        - name: ollama
          image: votre-registry/gemma4:latest
          ports:
            - containerPort: 11434
          resources:
            limits:
              nvidia.com/gpu: 1
          volumeMounts:
            - name: models
              mountPath: /root/.ollama
      volumes:
        - name: models
          persistentVolumeClaim:
            claimName: ollama-models-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: gemma4-service
spec:
  selector:
      app: gemma4
  ports:
    - port: 11434
      targetPort: 11434

💡 Pensez à externaliser le stockage des modèles dans un PVC pour éviter de les re-télécharger à chaque redémarrage de pod.

3. Intégration PHP/Symfony : function calling et RAG

Appel API de base depuis Symfony

Ollama expose une API compatible OpenAI. Vous pouvez utiliser le client HTTP de Symfony :

// src/Service/GemmaClient.php
use Symfony\Contracts\HttpClient\HttpClientInterface;

class GemmaClient
{
    public function __construct(
        private readonly HttpClientInterface $httpClient,
        private readonly string $baseUrl = 'http://gemma4-service:11434'
    ) {}

    public function chat(string $prompt, array $tools = []): array
    {
        $payload = [
            'model' => 'gemma4:26b-q5_k_m',
            'messages' => [['role' => 'user', 'content' => $prompt]],
            'stream' => false,
        ];

        if (!empty($tools)) {
            $payload['tools'] = $tools;
        }

        $response = $this->httpClient->request('POST', $this->baseUrl . '/api/chat', [
            'json' => $payload,
        ]);

        return $response->toArray();
    }
}

Exemple de function calling pour un agent

Gemma 4 supporte nativement le function calling et la sortie JSON structurée :

$tools = [
    [
        'type' => 'function',
        'function' => [
            'name' => 'get_product_stock',
            'description' => 'Retourne le stock disponible pour un produit donné',
            'parameters' => [
                'type' => 'object',
                'properties' => [
                    'product_id' => ['type' => 'string', 'description' => 'Identifiant du produit'],
                ],
                'required' => ['product_id'],
            ],
        ],
    ],
];

$result = $gemmaClient->chat(
    'Quel est le stock du produit SKU-4892 ?',
    $tools
);

// Le modèle retourne un appel structuré à dispatcher vers votre service métier
$toolCall = $result['message']['tool_calls'][0] ?? null;

RAG avec PostgreSQL pgvector

Pour un pipeline RAG (Retrieval-Augmented Generation), combinez Gemma 4 avec l'extension pgvector de PostgreSQL :

1. Embedding : générez les embeddings de vos documents avec un modèle léger (ex. nomic-embed-text via Ollama).
2. Stockage : insérez les vecteurs dans une colonne vector(768) PostgreSQL.
3. Requête : à chaque question utilisateur, récupérez les N chunks les plus proches par similarité cosinus.
4. Génération : injectez ces chunks dans le contexte système de Gemma 4 avant d'appeler le modèle.

-- Recherche des 5 chunks les plus pertinents
SELECT content, 1 - (embedding <=> $1::vector) AS score
FROM document_chunks
ORDER BY embedding <=> $1::vector
LIMIT 5;

Cette architecture vous garantit un contrôle total sur vos données, sans aucun appel vers l'extérieur.

Conclusion : une fenêtre d'opportunité à saisir

La combinaison licence Apache 2.0 + performances Gemini 3 + support natif du function calling fait de Gemma 4 le candidat le plus sérieux à ce jour pour du self-hosting en production. Pour une équipe PHP/Symfony, la stack Ollama + Docker/K8s + pgvector + HttpClient Symfony offre un chemin d'intégration direct, sans dépendance externe, avec une maîtrise totale des coûts et de la confidentialité.

Checklist récapitulative :

• Choisir la taille de modèle adaptée au hardware disponible
• Appliquer la quantization Q5_K_M pour la production
• Containeriser avec Docker et persister les modèles via un volume
• Déployer en tant que microservice HTTP dans Kubernetes
• Consommer l'API via HttpClientInterface Symfony
• Implémenter le function calling pour les agents métier
• Connecter pgvector pour les cas d'usage RAG

MulerTech accompagne les équipes dans ces intégrations. N'hésitez pas à nous contacter pour un audit de votre stack IA.