THE MEDIA FOR AI THAT ACTUALLY HELPS.French edition · Understand & take action
The interface is in English. Use cases, skills and articles remain in French.
Microsoft

Gérer des agents IA persistants, de bas niveau, en Java

azure-ai-agents-persistent-java

En bref

Le SDK Azure AI Agents Persistent pour Java est l’API de bas niveau pour créer et gérer des agents persistants, réutilisables d’une session à l’autre : agents, fils (threads), messages, exécutions (runs) et outils, via PersistentAgentsClient ou PersistentAgentsAsyncClient. Le flux typique du skill : créer un agent avec ses outils, créer un fil, y déposer un message, lancer un run, interroger le statut (y compris RequiresAction, Failed, Cancelled), lister les messages, puis supprimer le fil. Le SKILL.md insiste pour nettoyer fils et agents une fois le travail fini, et pour traiter tous les statuts d’exécution. Ce n’est pas le SDK de projet Foundry de haut niveau (connexions, datasets, index).

Ce que ça fait

  • Orchestre agents persistants, threads, messages, runs et outils, en synchrone ou asynchrone.
  • Demande de gérer explicitement chaque statut de run, notamment une action requise ou un échec.
  • Impose le nettoyage des fils et des agents pour éviter des ressources orphelines.
  • Reste un client bas niveau, distinct de la gestion de projet AI Projects.

Pour qui, et un exemple

Développeurs Java qui doivent contrôler précisément le cycle de vie d’un agent persistant, y compris le streaming et les outils.

Exemple de demande : On crée un agent outillé, on ouvre un fil, on lance un run, on attend la fin ou une action requise, on lit les messages, puis on supprime le fil.

Quand on cite PersistentAgentsClient, des agents persistants, des threads, des runs ou un streaming d’agents en Java. Exemple rédigé par iadujour.fr à partir du SKILL.md, non testé.

Installer

npx skills add microsoft/skills (sélection de la skill dans l’assistant, README).

npx skills add microsoft/skills

Fonctionne avec

  • GitHub Copilot
  • Copilot CLI

Source : README : exemples de « Copilot CLI » et « GitHub Copilot in VS Code » ; l’installation `npx skills add` envoie les fichiers vers le répertoire de l’agent choisi, sans liste exhaustive.

Niveau : Intermédiaire

Suppose un projet de l’éditeur et la maîtrise du SDK ou de la CLI correspondante.

À savoir

Dépôt officiel Microsoft ; le README le présente comme un travail en cours (skills et tests encore enrichis).

Extrait du SKILL.md

La description d’origine, celle que l’agent lit pour décider de charger la skill (en anglais) :

Azure AI Agents Persistent SDK for Java. Low-level SDK for creating and managing AI agents with threads, messages, runs, and tools. Triggers: "PersistentAgentsClient", "persistent agents java", "agent threads java", "agent runs java", "streaming agents java".

Citée depuis le SKILL.md au commit e7ee58f . Le dossier contient aussi 1 fichier annexe (references/).

Le SKILL.md compte 140 lignes et 15 sections principales :

  • Installation
  • Environment Variables
  • Authentication
  • Key Concepts
  • Client Hierarchy
  • Core Workflow
  • 1. Create Agent
  • 2. Create Thread
  • 3. Add Message
  • 4. Run Agent
  • 5. Get Response
  • 6. Cleanup
  • Best Practices
  • Error Handling
  • Reference Links

Licence : MIT

Vérifiée le 10 novembre 2026 sur : fichier LICENSE du dépôt . Licence déclarée dans le frontmatter : « MIT ». Titulaire : Copyright (c) Microsoft Corporation..

La licence autorise la reprise : le texte intégral du SKILL.md est reproduit ci-dessous, sans modification, avec sa mention de licence.

Texte intégral du SKILL.md

Reproduit sans modification depuis microsoft/skills (commit e7ee58f) , © Microsoft, sous licence MIT (fichier de licence d’origine ).

Afficher le SKILL.md original (140 lignes, en anglais)
---
name: azure-ai-agents-persistent-java
description: |
  Azure AI Agents Persistent SDK for Java. Low-level SDK for creating and managing AI agents with threads, messages, runs, and tools.
  Triggers: "PersistentAgentsClient", "persistent agents java", "agent threads java", "agent runs java", "streaming agents java".
license: MIT
metadata:
  author: Microsoft
  version: "1.0.0"
  package: com.azure:azure-ai-agents-persistent
---

# Azure AI Agents Persistent SDK for Java

Low-level SDK for creating and managing persistent AI agents with threads, messages, runs, and tools.

## Installation

```xml
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-agents-persistent</artifactId>
    <version>1.0.0-beta.1</version>
</dependency>
```

## Environment Variables

```bash
PROJECT_ENDPOINT=https://<resource>.services.ai.azure.com/api/projects/<project> # Required for project configuration
MODEL_DEPLOYMENT_NAME=gpt-4o-mini # Required for agent model selection
AZURE_TOKEN_CREDENTIALS=prod  # Required only if DefaultAzureCredential is used in production
```

## Authentication

```java
import com.azure.ai.agents.persistent.PersistentAgentsClient;
import com.azure.ai.agents.persistent.PersistentAgentsClientBuilder;
import com.azure.core.credential.TokenCredential;
import com.azure.identity.AzureIdentityEnvVars;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.ManagedIdentityCredentialBuilder;

String endpoint = System.getenv("PROJECT_ENDPOINT");
TokenCredential credential = new DefaultAzureCredentialBuilder()
    .requireEnvVars(AzureIdentityEnvVars.AZURE_TOKEN_CREDENTIALS)
    .build();
// Or use a specific credential directly in production:
// See https://learn.microsoft.com/java/api/overview/azure/identity-readme?view=azure-java-stable#credential-classes
// TokenCredential credential = new ManagedIdentityCredentialBuilder().build();

PersistentAgentsClient client = new PersistentAgentsClientBuilder()
    .endpoint(endpoint)
    .credential(credential)
    .buildClient();
```

## Key Concepts

The Azure AI Agents Persistent SDK provides a low-level API for managing persistent agents that can be reused across sessions.

### Client Hierarchy

| Client | Purpose |
|--------|---------|
| `PersistentAgentsClient` | Sync client for agent operations |
| `PersistentAgentsAsyncClient` | Async client for agent operations |

## Core Workflow

### 1. Create Agent

```java
// Create agent with tools
PersistentAgent agent = client.createAgent(
    modelDeploymentName,
    "Math Tutor",
    "You are a personal math tutor."
);
```

### 2. Create Thread

```java
PersistentAgentThread thread = client.createThread();
```

### 3. Add Message

```java
client.createMessage(
    thread.getId(),
    MessageRole.USER,
    "I need help with equations."
);
```

### 4. Run Agent

```java
ThreadRun run = client.createRun(thread.getId(), agent.getId());

// Poll for completion
while (run.getStatus() == RunStatus.QUEUED || run.getStatus() == RunStatus.IN_PROGRESS) {
    Thread.sleep(500);
    run = client.getRun(thread.getId(), run.getId());
}
```

### 5. Get Response

```java
PagedIterable<PersistentThreadMessage> messages = client.listMessages(thread.getId());
for (PersistentThreadMessage message : messages) {
    System.out.println(message.getRole() + ": " + message.getContent());
}
```

### 6. Cleanup

```java
client.deleteThread(thread.getId());
client.deleteAgent(agent.getId());
```

## Best Practices

1. **Use DefaultAzureCredential** for production authentication
2. **Poll with appropriate delays** — 500ms recommended between status checks
3. **Clean up resources** — Delete threads and agents when done
4. **Handle all run statuses** — Check for RequiresAction, Failed, Cancelled
5. **Use async client** for better throughput in high-concurrency scenarios

## Error Handling

```java
import com.azure.core.exception.HttpResponseException;

try {
    PersistentAgent agent = client.createAgent(modelName, name, instructions);
} catch (HttpResponseException e) {
    System.err.println("Error: " + e.getResponse().getStatusCode() + " - " + e.getMessage());
}
```

## Reference Links

| Resource | URL |
|----------|-----|
| Maven Package | https://central.sonatype.com/artifact/com.azure/azure-ai-agents-persistent |
| GitHub Source | https://github.com/Azure/azure-sdk-for-java/tree/main/sdk/ai/azure-ai-agents-persistent |
Source. Fiche rédigée par iadujour.fr à partir de : Frontmatter, sections et corps du SKILL.md, README du dépôt. Consultée le 10 novembre 2026. Dépôt : microsoft/skills .

Dans l’annuaire

Cas d’usage et guides qui partagent un thème, un métier ou un outil avec cette skill.

DANS L’ANNUAIRE

Cas d’usage liés.

Des fiches de l’annuaire qui partagent au moins deux mots-clés précis avec cette skill.

MÊME ÉDITEUR

Autres skills Microsoft : Agents et skills

Toute la catégorie
MicrosoftAgents et skills

Recommander une skill Azure adaptée à la tâche

discover-azure-skills

On recourt à cette skill pour la recherche dans le catalogue des skills Azure, pour recommander une skill d’agent installable qui correspond à une tâche Azure : lister les greffons et les skills depuis l’API GitHub du dépôt `microsoft/azure-skills`, lire les descriptions, retrouver le nom du greffon dans `plugin.json` (qui peut différer du nom de dossier), puis proposer les instructions d’installation selon le client (Copilot CLI, Claude Code, ou autre).

Outils : GitHub Copilot, Copilot CLINiveau : Intermédiairemàj 03/11/2026
ÉCHANGES

Commentaires.

Un retour d’expérience, une question, une précision sur cette skill ? Les commentaires sont relus avant publication.

Commentaires publiés

Chargement des commentaires…

    Laisser un commentaire

    Charte de modération. Chaque commentaire est relu avant publication. Sont refusés : l’incitation à la haine, les propos injurieux ou discriminatoires, la publicité, le spam et les liens promotionnels, le hors-sujet et les données personnelles d’autrui.