AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

azure-ai-projects-java

Azure AI Projects SDK for Java. High-level SDK for Azure AI Foundry project management including connections, datasets, indexes, and evaluations. Triggers: "AIProjectClient java", "azure ai projects java", "Foundry project java", "ConnectionsClient", "DatasetsClient", "IndexesClient".

Original source
microsoft
License
MIT
Pinned revision
3f5b461b2314e01c400564051e92469114c5b68f

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

Ask your assistant

Use Agentic Memory skills to read microsoft--azure-ai-projects-java at revision 3f5b461b2314e01c400564051e92469114c5b68f, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 2

references/examples.md

Azure AI Projects Java SDK - Examples

Comprehensive code examples for the Azure AI Projects SDK for Java.

Table of Contents


Maven Dependency

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-projects</artifactId>
    <version>1.0.0-beta.1</version>
</dependency>

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.15.3</version>
</dependency>

Client Creation

Creating AIProjectClient and Sub-Clients

import com.azure.ai.projects.*;
import com.azure.core.util.Configuration;
import com.azure.identity.DefaultAzureCredentialBuilder;

public class ClientInitializationSample {

    public static void main(String[] args) {
        // Create the builder with endpoint and credentials
        AIProjectClientBuilder builder = new AIProjectClientBuilder()
            .endpoint(Configuration.getGlobalConfiguration().get("AZURE_AI_PROJECTS_ENDPOINT"))
            .credential(new DefaultAzureCredentialBuilder().build());

        // Build specific sub-clients as needed
        ConnectionsClient connectionsClient = builder.buildConnectionsClient();
        DatasetsClient datasetsClient = builder.buildDatasetsClient();
        DeploymentsClient deploymentsClient = builder.buildDeploymentsClient();
        EvaluationRulesClient evaluationRulesClient = builder.buildEvaluationRulesClient();
        EvaluationsClient evaluationsClient = builder.buildEvaluationsClient();
        EvaluationTaxonomiesClient evaluationTaxonomiesClient = builder.buildEvaluationTaxonomiesClient();
        EvaluatorsClient evaluatorsClient = builder.buildEvaluatorsClient();
        IndexesClient indexesClient = builder.buildIndexesClient();
        InsightsClient insightsClient = builder.buildInsightsClient();
        RedTeamsClient redTeamsClient = builder.buildRedTeamsClient();
        SchedulesClient schedulesClient = builder.buildSchedulesClient();
        
        // For async clients, use the async builder methods
        ConnectionsAsyncClient connectionsAsyncClient = builder.buildConnectionsAsyncClient();
        DatasetsAsyncClient datasetsAsyncClient = builder.buildDatasetsAsyncClient();
        DeploymentsAsyncClient deploymentsAsyncClient = builder.buildDeploymentsAsyncClient();
    }
}

Working with Connections

List Connections

import com.azure.ai.projects.models.Connection;
import com.azure.ai.projects.models.ConnectionType;
import com.azure.core.http.rest.PagedIterable;

public class ConnectionsSample {

    private static ConnectionsClient connectionsClient;

    public static void listConnections() {
        PagedIterable<Connection> connections = connectionsClient.listConnections();
        for (Connection connection : connections) {
            System.out.println("Connection name: " + connection.getName());
            System.out.println("Connection type: " + connection.getType());
            System.out.println("Connection credential type: " + connection.getCredentials().getType());
            System.out.println("-------------------------------------------------");
        }
    }

    public static void getConnectionWithoutCredentials() {
        String connectionName = "my-connection";
        Connection connection = connectionsClient.getConnection(connectionName);
        System.out.printf("Connection name: %s%n", connection.getName());
    }

    public static void getConnectionWithCredentials() {
        String connectionName = "my-connection";
        Connection connection = connectionsClient.getConnectionWithCredentials(connectionName);
        System.out.printf("Connection name: %s%n", connection.getName());
        System.out.printf("Connection credentials: %s%n", connection.getCredentials().getType());
    }

    // Filter connections by type
    public static void listConnectionsWithFilters() {
        // List only Azure OpenAI connections
        Iterable<Connection> azureOpenAIConnections = 
            connectionsClient.listConnections(ConnectionType.AZURE_OPEN_AI, null);
        
        azureOpenAIConnections.forEach(connection -> {
            System.out.println("Azure OpenAI Connection: " + connection.getName());
        });

        // List only default connections
        Iterable<Connection> defaultConnections = connectionsClient.listConnections(null, true);
        defaultConnections.forEach(connection -> {
            System.out.println("Default Connection: " + connection.getName());
        });
    }
}

Working with Deployments

List and Get Deployments

import com.azure.ai.projects.models.Deployment;
import com.azure.core.http.rest.PagedIterable;

public class DeploymentsSample {

    private static DeploymentsClient deploymentsClient;

    public static void listDeployments() {
        PagedIterable<Deployment> deployments = deploymentsClient.list();
        for (Deployment deployment : deployments) {
            System.out.printf("Deployment name: %s%n", deployment.getName());
        }
    }

    public static void getDeployment() {
        String deploymentName = "gpt-4o";
        Deployment deployment = deploymentsClient.get(deploymentName);

        System.out.printf("Deployment name: %s%n", deployment.getName());
        System.out.printf("Deployment type: %s%n", deployment.getType().getValue());
    }
}

Working with Datasets

Create Dataset with File Upload

import com.azure.ai.projects.models.DatasetVersion;
import com.azure.ai.projects.models.FileDatasetVersion;

import java.nio.file.Path;

public class DatasetsSample {

    private static DatasetsClient datasetsClient;

    // Create a dataset by uploading a file
    public static void createDatasetWithFile() {
        String datasetName = "my-dataset";
        String datasetVersionString = "1.0";

        Path filePath = Path.of("product_info.md");

        FileDatasetVersion createdDatasetVersion = datasetsClient.createDatasetWithFile(
            datasetName, 
            datasetVersionString, 
            filePath
        );

        System.out.println("Created dataset version: " + createdDatasetVersion.getId());
    }

    // List all datasets (latest versions)
    public static void listDatasets() {
        System.out.println("Listing all datasets (latest versions):");
        datasetsClient.listLatest().forEach(dataset -> {
            System.out.println("\nDataset name: " + dataset.getName());
            System.out.println("Dataset Id: " + dataset.getId());
            System.out.println("Dataset version: " + dataset.getVersion());
            System.out.println("Dataset type: " + dataset.getType());
            if (dataset.getDescription() != null) {
                System.out.println("Description: " + dataset.getDescription());
            }
        });
    }

    // List all versions of a specific dataset
    public static void listDatasetVersions() {
        String datasetName = "my-dataset";

        System.out.println("Listing all versions of dataset: " + datasetName);
        datasetsClient.listVersions(datasetName).forEach(version -> {
            System.out.println("\nDataset name: " + version.getName());
            System.out.println("Dataset version: " + version.getVersion());
            System.out.println("Dataset type: " + version.getType());
            if (version.getDataUri() != null) {
                System.out.println("Data URI: " + version.getDataUri());
            }
        });
    }

    // Get a specific dataset version
    public static void getDataset() {
        String datasetName = "my-dataset";
        String datasetVersion = "1.0";

        DatasetVersion dataset = datasetsClient.getDatasetVersion(datasetName, datasetVersion);

        System.out.println("Retrieved dataset:");
        System.out.println("Name: " + dataset.getName());
        System.out.println("Version: " + dataset.getVersion());
        System.out.println("Type: " + dataset.getType());
    }

    // Create or update a dataset with a data URI
    public static void createOrUpdateDataset() {
        String datasetName = "my-dataset";
        String datasetVersion = "1.0";
        String dataUri = "https://example.com/data.txt";

        // Create a new FileDatasetVersion with provided dataUri
        FileDatasetVersion fileDataset = new FileDatasetVersion()
            .setDataUri(dataUri)
            .setDescription("Sample dataset created via SDK");

        // Create or update the dataset
        FileDatasetVersion createdDataset = (FileDatasetVersion) datasetsClient.createOrUpdateVersion(
            datasetName, 
            datasetVersion, 
            fileDataset
        );

        System.out.println("Created/Updated dataset:");
        System.out.println("Name: " + createdDataset.getName());
        System.out.println("Version: " + createdDataset.getVersion());
        System.out.println("Data URI: " + createdDataset.getDataUri());
    }

    // Delete a dataset version
    public static void deleteDataset() {
        String datasetName = "my-dataset";
        String datasetVersion = "1.0";

        datasetsClient.deleteVersion(datasetName, datasetVersion);
        System.out.println("Dataset version deleted successfully");
    }
}

Async Clients

List Connections (Async)

import com.azure.ai.projects.models.Connection;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public class ConnectionsAsyncSample {

    private static ConnectionsAsyncClient connectionsAsyncClient;

    public static Flux<Connection> listConnections() {
        return connectionsAsyncClient.listConnections()
            .doOnNext(connection -> System.out.printf("Connection name: %s%n", connection.getName()));
    }

    public static Mono<Connection> getConnectionWithoutCredentials() {
        String connectionName = "my-connection";
        return connectionsAsyncClient.getConnection(connectionName)
            .doOnNext(connection -> System.out.printf("Connection name: %s%n", connection.getName()));
    }

    public static Mono<Connection> getConnectionWithCredentials() {
        String connectionName = "my-connection";
        return connectionsAsyncClient.getConnectionWithCredentials(connectionName)
            .doOnNext(connection -> {
                System.out.printf("Connection name: %s%n", connection.getName());
                System.out.printf("Connection credentials: %s%n", connection.getCredentials().getType());
            });
    }

    public static void main(String[] args) {
        // Using block() to wait for the async operations to complete in the sample
        listConnections().blockLast();
        getConnectionWithoutCredentials().block();
        getConnectionWithCredentials().block();
    }
}

Datasets (Async)

import com.azure.ai.projects.models.DatasetVersion;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public class DatasetsAsyncSample {

    private static DatasetsAsyncClient datasetsAsyncClient;

    public static Flux<DatasetVersion> listLatestDatasets() {
        return datasetsAsyncClient.listLatest()
            .doOnNext(dataset -> {
                System.out.println("Dataset: " + dataset.getName());
                System.out.println("Version: " + dataset.getVersion());
            });
    }

    public static Mono<DatasetVersion> getDataset(String name, String version) {
        return datasetsAsyncClient.getDatasetVersion(name, version)
            .doOnNext(dataset -> {
                System.out.println("Retrieved: " + dataset.getName());
            });
    }

    public static void main(String[] args) {
        listLatestDatasets().blockLast();
        getDataset("my-dataset", "1.0").block();
    }
}