Edit

Share via

Generate images from text using AI

In this quickstart, you use the Microsoft.Extensions.AI (MEAI) library to generate images from text prompts using an AI model. The MEAI text-to-image capabilities let you generate images from natural language prompts or existing images using a consistent and extensible API surface.

The IImageGenerator interface provides a unified, extensible API for working with various image generation services, making it easy to integrate text-to-image capabilities into your .NET apps. The interface supports:

  • Text-to-image generation.
  • Pipeline composition with middleware (logging, telemetry, caching).
  • Flexible configuration options.
  • Support for multiple AI providers.

Note

The IImageGenerator interface is currently marked as experimental with the MEAI001 diagnostic ID. You might need to suppress this warning in your project file or code.

Prerequisites

Configure the AI service

To provision an Azure OpenAI service and model using the Azure portal, complete the steps in the Create and deploy an Azure OpenAI Service resource article. In the "Deploy a model" step, select the gpt-image-1 model.

Note

gpt-image-1 is a newer model that offers several improvements over DALL-E 3. It's available from OpenAI on a limited basis; apply for access with this form.

Create the application

Complete the following steps to create a .NET console application that generates images from text prompts.

  1. Create a new console application:

    dotnet new console -o TextToImageAI

  2. Navigate to the TextToImageAI directory, and add the necessary packages to your app:

    dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

  3. Run the following commands to add app secrets for your Azure OpenAI endpoint, model name, and API key:

    dotnet user-secrets init
dotnet user-secrets set AZURE_OPENAI_ENDPOINT <your-Azure-OpenAI-endpoint>
dotnet user-secrets set AZURE_OPENAI_GPT_NAME gpt-image-1
dotnet user-secrets set AZURE_OPENAI_API_KEY <your-azure-openai-api-key>

  4. Open the new app in your editor of choice (for example, Visual Studio).

Implement basic image generation

  1. Update the Program.cs file with the following code to get the configuration data and create the AzureOpenAIClient:

    using Azure;
using Azure.AI.OpenAI;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;

IConfigurationRoot config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

string endpoint = config["AZURE_OPENAI_ENDPOINT"];
string apiKey = config["AZURE_OPENAI_API_KEY"];
string model = config["AZURE_OPENAI_GPT_NAME"];

// Create the Azure OpenAI client and convert to IImageGenerator.
AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(apiKey));

var imageClient = azureClient.GetImageClient(model);
#pragma warning disable MEAI001 // Type is for evaluation purposes only.
IImageGenerator generator = imageClient.AsIImageGenerator();

    The preceding code:

    • Loads configuration from user secrets.
    • Creates an ImageClient from the OpenAI SDK.
    • Converts the ImageClient to an IImageGenerator using the AsIImageGenerator(ImageClient) extension method.

  2. Add the following code to implement basic text-to-image generation:

    // Generate an image from a text prompt
var options = new ImageGenerationOptions
{
    MediaType = "image/png"
};
string prompt = "A tennis court in a jungle";
var response = await generator.GenerateImagesAsync(prompt, options);

// Save the image to a file.
var dataContent = response.Contents.OfType<DataContent>().First();
string fileName = SaveImage(dataContent, "jungle-tennis.png");
Console.WriteLine($"Image saved to file: {fileName}");

static string SaveImage(DataContent content, string fileName)
{
    string userDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
    var path = Path.Combine(userDirectory, fileName);
    File.WriteAllBytes(path, content.Data.ToArray());
    return Path.GetFullPath(path);
}

    The preceding code:

  3. Run the application, either through the IDE or using dotnet run.

    The application generates an image and outputs the file path to the image. Open the file to view the generated image. The following image shows one example of a generated image.

    AI-generated image of a tennis court in a jungle.

Configure image generation options

You can customize image generation by providing other options such as size, response format, and number of images to generate. The ImageGenerationOptions class allows you to specify:

Best practices

When implementing text-to-image generation in your applications, consider these best practices:

  • Prompt engineering: Write clear, detailed prompts that describe the desired image. Include specific details about style, composition, colors, and elements.
  • Cost management: Image generation can be expensive. Cache results when possible and implement rate limiting to control costs.
  • Content safety: Always review generated images for appropriate content, especially in production applications. Consider implementing content filtering and moderation.
  • User experience: Image generation can take several seconds. Provide progress indicators and handle timeouts gracefully.
  • Legal considerations: Be aware of licensing and usage rights for generated images. Review the terms of service for your AI provider.

Clean up resources

When you no longer need the Azure OpenAI resource, delete it to avoid incurring charges:

  1. In the Azure Portal, navigate to your Azure OpenAI resource.
  2. Select the resource and then select Delete.

Next steps

You've successfully generated some different images using the IImageGenerator interface in Microsoft.Extensions.AI. Next, you can explore some of the additional functionality, including:

  • Refining the generated image iteratively.
  • Editing an existing image.
  • Personalizing an image, diagram, or theme.

See also