Orchardcore AI

Orchard Core AI - Prompt Templates

Configure AI Integration

You are an Orchard Core expert. Generate code and configuration for AI integrations in Orchard Core.

Guidelines

• Orchard Core supports AI integrations through the CrestApps AI module ecosystem.
• Supported AI providers: OpenAI, Azure, AzureAIInference, and Ollama.
• Configure AI services through appsettings.json or the admin UI.
• Use dependency injection to access AI services in modules.
• Always secure API keys using user secrets or environment variables, never hardcode them.
• Provider configuration no longer uses a provider-wide default connection property. When multiple shared connections exist, assign the intended ConnectionName on each deployment and select deployments by name in profiles, workflows, and interactions.
• AI profiles define how the AI system interacts with users, including system messages and response behavior.
• Profile types include Chat, Utility, TemplatePrompt, and Agent.
• Agent profiles are reusable agents exposed as AI tools — each agent requires a Description field.
• Agent availability: OnDemand (default, included via selection) or AlwaysAvailable (auto-included in every request).
• Resolve a speech-to-text deployment before creating an ISpeechToTextClient; IAIClientFactory.CreateSpeechToTextClientAsync() accepts an AIDeployment, not provider and connection names.

Enabling AI Features

{
  "steps": [
    {
      "name": "Feature",
      "enable": [
        "CrestApps.OrchardCore.AI"
      ],
      "disable": []
    }
  ]
}

AI Configuration in appsettings.json

{
  "OrchardCore": {
    "CrestApps": {
      "AI": {
        "DefaultParameters": {
          "Temperature": 0,
          "MaxOutputTokens": 800,
          "TopP": 1,
          "FrequencyPenalty": 0,
          "PresencePenalty": 0,
          "PastMessagesCount": 10
        },
        "Connections": [
          {
            "Name": "default",
            "ClientName": "OpenAI",
            "Endpoint": "https://api.openai.com/v1",
            "ApiKey": "Use a secret provider"
          }
        ],
        "Deployments": [
          { "Name": "gpt-4o", "ClientName": "OpenAI", "ConnectionName": "default", "Purpose": "Chat" },
          { "Name": "gpt-4o-mini", "ClientName": "OpenAI", "ConnectionName": "default", "Purpose": "Utility" },
          { "Name": "text-embedding-3-large", "ClientName": "OpenAI", "ConnectionName": "default", "Purpose": "Embedding" },
          { "Name": "dall-e-3", "ClientName": "OpenAI", "ConnectionName": "default", "Purpose": "Image" }
        ]
      }
    }
  }
}

Non-Connection Deployments via appsettings.json

Contained-connection providers (for example, Azure Speech) can be defined in the OrchardCore:CrestApps:AI:Deployments section. These deployments embed their own connection parameters and do not reference a shared provider connection.

{
  "OrchardCore": {
    "CrestApps": {
      "AI": {
        "Deployments": [
          {
            "ClientName": "AzureSpeech",
            "Name": "my-speech-to-text",
            "Purpose": "SpeechToText",
            "Endpoint": "https://eastus.api.cognitive.microsoft.com/",
            "AuthenticationType": "ApiKey",
            "ApiKey": "Use a secret provider"
          }
        ]
      }
    }
  }
}

Deployments defined in configuration are read-only, ephemeral (exist only while in config), and appear alongside database-managed deployments in dropdown menus and API queries.

Typed AI Deployment Settings

Each deployment in the Deployments array has these properties:

Use ClientName for deployments in recipes and configuration.

Adding AI Provider Connection via Recipe

{
  "steps": [
    {
      "name": "AIProviderConnections",
      "connections": [
        {
          "Source": "OpenAI",
          "Name": "default",
          "DisplayText": "OpenAI",
          "Properties": {
            "OpenAIConnectionMetadata": {
              "Endpoint": "https://api.openai.com/v1",
              "ApiKey": "{{YourApiKey}}"
            }
          }
        }
      ]
    }
  ]
}

Managing AI Deployments via Recipe

{
  "steps": [
    {
      "name": "AIDeployment",
      "deployments": [
        {
          "ItemId": "openai-chat",
          "Name": "gpt-4o",
          "ClientName": "OpenAI",
          "ConnectionName": "default",
          "Purpose": "Chat",
          "IsDefault": true
        },
        {
          "ItemId": "openai-utility",
          "Name": "gpt-4o-mini",
          "ClientName": "OpenAI",
          "ConnectionName": "default",
          "Purpose": "Utility",
          "IsDefault": true
        }
      ]
    }
  ]
}

For new recipes, prefer a dedicated AIDeployment step over embedding deployment definitions inside AIProviderConnections.

AI Completion using Direct Config Workflow Task

The AICompletionWithConfigTask workflow activity is now deployment-driven. Its editor (AICompletionWithConfigTaskDisplayDriver) should only ask the user to select a chat deployment plus the prompt and output settings.

• Do not ask for ProviderName or ConnectionName.
• Populate the deployment dropdown from IAIDeploymentManager.GetByPurposeAsync(AIDeploymentPurpose.Chat).
• Persist the selected deployment using DeploymentName.
• At execution time, resolve the deployment with ResolveOrDefaultAsync(AIDeploymentPurpose.Chat, deploymentName: DeploymentName).

public sealed class AICompletionWithConfigTaskDisplayDriver
    : ActivityDisplayDriver<AICompletionWithConfigTask, AICompletionWithConfigTaskViewModel>
{
    private readonly IAIDeploymentManager _deploymentManager;

    public override IDisplayResult Edit(AICompletionWithConfigTask activity, BuildEditorContext context)
    {
        return Initialize<AICompletionWithConfigTaskViewModel>("AICompletionWithConfigTask_Fields_Edit", async model =>
        {
            model.DeploymentName = activity.DeploymentName;
            model.DeploymentNames = (await _deploymentManager.GetByPurposeAsync(AIDeploymentPurpose.Chat))
                .OrderBy(x => x.ConnectionNameAlias ?? x.ConnectionName)
                .ThenBy(x => x.Name)
                .Select(x => new SelectListItem(x.Name, x.Name));
        }).Location("Content");
    }
}

<div class="ocat-wrapper" asp-validation-class-for="DeploymentName">
    <label asp-for="DeploymentName" class="ocat-label">@T["Deployment"]</label>
    <div class="ocat-end">
        <select asp-for="DeploymentName" class="form-select" asp-items="Model.DeploymentNames">
            <option value="">@T["Select a deployment"]</option>
        </select>
    </div>
</div>

Use this workflow activity when a workflow should target a specific deployment directly instead of going through an AI profile.

AI Profile Types

Creating AI Profiles via Recipe

{
  "steps": [
    {
      "name": "AIProfile",
      "profiles": [
        {
          "Name": "{{ProfileName}}",
          "DisplayText": "{{DisplayName}}",
          "WelcomeMessage": "{{WelcomeMessage}}",
          "Description": "",
          "Type": "Chat",
          "TitleType": "InitialPrompt",
          "PromptTemplate": null,
          "ChatDeploymentName": "gpt-4o",
          "UtilityDeploymentName": "gpt-4o-mini",
          "Properties": {
            "AIProfileMetadata": {
              "SystemMessage": "{{SystemMessage}}",
              "Temperature": null,
              "TopP": null,
              "FrequencyPenalty": null,
              "PresencePenalty": null,
              "MaxTokens": null,
              "PastMessagesCount": null
            },
            "FunctionInvocationMetadata": { "Names": [] },
            "AgentInvocationMetadata": { "Names": [] }
          }
        }
      ]
    }
  ]
}

The AIProfile recipe step is source-agnostic. Omit Source and use ChatDeploymentName and UtilityDeploymentName to select the deployments by their technical names.

Creating an Agent Profile via Recipe

Agent profiles are exposed as AI tools that other profiles/interactions can invoke. The Description field is required — it's used by the LLM to decide when to invoke the agent.

{
  "steps": [
    {
      "name": "AIProfile",
      "profiles": [
        {
          "Name": "research-agent",
          "DisplayText": "Research Agent",
          "Description": "An agent that can research topics on the internet and provide comprehensive summaries with citations.",
          "Type": "Agent",
          "TitleType": "InitialPrompt",
          "ChatDeploymentName": "gpt-4o",
          "UtilityDeploymentName": "gpt-4o-mini",
          "Properties": {
            "AIProfileMetadata": {
              "SystemMessage": "You are a research assistant. Gather information, verify facts, and provide comprehensive answers with sources.",
              "Temperature": 0.3,
              "MaxTokens": 4096
            },
            "AgentMetadata": {
              "Availability": "OnDemand"
            }
          }
        }
      ]
    }
  ]
}

Agent Availability

Defining Chat Profiles Using Code

public sealed class SystemDefinedAIProfileMigrations : DataMigration
{
    private readonly IAIProfileManager _profileManager;

    public SystemDefinedAIProfileMigrations(IAIProfileManager profileManager)
    {
        _profileManager = profileManager;
    }

    public async Task<int> CreateAsync()
    {
        var profile = await _profileManager.NewAsync();

        profile.Name = "UniqueTechnicalName";
        profile.DisplayText = "A Display name for the profile";
        profile.Type = AIProfileType.Chat;

        profile.WithSettings(new AIProfileSettings
        {
            LockSystemMessage = true,
            IsRemovable = false,
            IsListable = false,
        });

        profile.WithSettings(new AIChatProfileSettings
        {
            IsOnAdminMenu = true,
        });

        profile.Put(new AIProfileMetadata
        {
            SystemMessage = "some system message",
            Temperature = 0.3f,
            MaxTokens = 4096,
        });

        await _profileManager.SaveAsync(profile);

        return 1;
    }
}

Creating an Agent Profile in Code

public async Task<int> CreateAsync()
{
    var profile = await _profileManager.NewAsync();

    profile.Name = "research-agent";
    profile.DisplayText = "Research Agent";
    profile.Description = "Researches topics and provides comprehensive summaries with citations.";
    profile.Type = AIProfileType.Agent;

    profile.Put(new AIProfileMetadata
    {
        SystemMessage = "You are a research assistant...",
        Temperature = 0.3f,
        MaxTokens = 4096,
    });

    profile.Put(new AgentMetadata
    {
        Availability = AgentAvailability.OnDemand,
    });

    await _profileManager.SaveAsync(profile);
    return 1;
}

Using ISpeechToTextClient

public sealed class MySpeechService
{
    private readonly IAIClientFactory _clientFactory;
    private readonly IAIDeploymentManager _deploymentManager;

    public MySpeechService(
        IAIClientFactory clientFactory,
        IAIDeploymentManager deploymentManager)
    {
        _clientFactory = clientFactory;
        _deploymentManager = deploymentManager;
    }

    public async Task<string> TranscribeAsync(Stream audioStream, string deploymentName)
    {
        var deployment = await _deploymentManager.ResolveOrDefaultAsync(
            AIDeploymentPurpose.SpeechToText,
            deploymentName: deploymentName);
        var client = await _clientFactory.CreateSpeechToTextClientAsync(deployment);

        var response = await client.GetTextAsync(audioStream);

        return response.Text;
    }
}

Note: ISpeechToTextClient is supported by OpenAI and Azure OpenAI providers. Ollama and Azure AI Inference throw NotSupportedException.

Using ITextToSpeechClient

IAIClientFactory also provides CreateTextToSpeechClientAsync() for text-to-speech synthesis:

public sealed class MyTtsService
{
    private readonly IAIClientFactory _clientFactory;

    public MyTtsService(IAIClientFactory clientFactory)
    {
        _clientFactory = clientFactory;
    }

    public async IAsyncEnumerable<TextToSpeechUpdate> SynthesizeAsync(string text, string voiceName = null)
    {
        // Use an AIDeployment for the TTS model
        var deployment = ...; // Resolve from IAIDeploymentManager
        var client = await _clientFactory.CreateTextToSpeechClientAsync(deployment);

        using (client)
        {
            var options = new TextToSpeechOptions();
            if (!string.IsNullOrWhiteSpace(voiceName))
            {
                options.VoiceName = voiceName;
            }

            await foreach (var update in client.GetStreamingAudioAsync(text, options))
            {
                yield return update;
            }
        }
    }
}

Getting Available Speech Voices

Providers that support TTS also expose available voices:

var provider = ...; // Resolve IAIClientProvider
var voices = await provider.GetSpeechVoicesAsync(connection, deploymentName);
// Each SpeechVoice has Id, Name, Language, Gender, and VoiceSampleUrl

DefaultAIDeploymentSettings

The site-level DefaultAIDeploymentSettings configures default deployments for various AI capabilities:

Chat Mode

AI profiles of type Chat support a ChatMode setting that controls voice features:

ChatMode is configured per profile via ChatModeProfileSettings:

profile.AlterSettings<ChatModeProfileSettings>(s =>
{
    s.ChatMode = ChatMode.Conversation;
    s.VoiceName = "en-US-JennyNeural"; // Optional, uses default voice if empty
});

Important: ChatModeProfileSettings is stored on AIProfile.Settings (not Entity.Properties). Always use profile.TryGetSettings<ChatModeProfileSettings>() to read and profile.AlterSettings<ChatModeProfileSettings>() to write. Do not read this data from Entity.Properties because that is a different storage location.

Contained Connections

AI deployments can use contained connections — embedded connection details stored directly within the deployment rather than referencing a shared provider connection. This is useful for deployments that use a different endpoint or credentials than the shared connection (e.g., a dedicated Azure Speech Service endpoint for STT/TTS).

Contained connections appear in the admin UI with a "Contained Connection" badge instead of a connection name.

Extending AI Chat with Custom Functions

public sealed class GetWeatherFunction : AIFunction
{
    public const string TheName = "get_weather";

    private static readonly JsonElement _jsonSchema = JsonSerializer.Deserialize<JsonElement>(
    """
     {
       "type": "object",
       "properties": {
         "Location": {
           "type": "string",
           "description": "The geographic location for which the weather information is requested."
         }
       },
       "additionalProperties": false,
       "required": ["Location"]
     }
    """);

    public override string Name => TheName;

    public override string Description => "Retrieves weather information for a specified location.";

    public override JsonElement JsonSchema => _jsonSchema;

    protected override ValueTask<object> InvokeCoreAsync(AIFunctionArguments arguments, CancellationToken cancellationToken)
    {
        if (!arguments.TryGetValue("Location", out var prompt) || prompt is null)
        {
            return ValueTask.FromResult<object>("Location is required.");
        }

        var location = prompt is JsonElement jsonElement
            ? jsonElement.GetString()
            : prompt?.ToString();

        var weather = Random.Shared.NextDouble() > 0.5
            ? $"It's sunny in {location}."
            : $"It's raining in {location}.";

        return ValueTask.FromResult<object>(weather);
    }
}

Registering Custom AI Tools

services.AddCoreAITool<GetWeatherFunction>(GetWeatherFunction.TheName)
    .Selectable();

Or with configuration options:

services.AddCoreAITool<GetWeatherFunction>(GetWeatherFunction.TheName)
    .WithTitle("Weather Getter")
    .WithDescription("Retrieves weather information for a specified location.")
    .WithCategory("Service")
    .Selectable();

Security Best Practices

• Store API keys in user secrets during development: dotnet user-secrets set "OrchardCore:CrestApps:AI:Connections:0:ApiKey" "your-key"
• Use environment variables in production.
• Apply appropriate permissions to restrict AI feature access.
• Monitor token usage and set rate limits for production deployments.