AI integration in .NET applications is evolving rapidly. But without structure, it can easily become a collection of scattered prompts, hardcoded tool calls, and tightly coupled logic.

The CrestApps.AgentSkills ecosystem provides a clean, layered architecture for defining, organizing, and exposing AI skills in .NET — with first-class support for the Model Context Protocol (MCP) and OrchardCore.

This post walks through the projects in the repository and explains how they fit together — based strictly on their actual structure and purpose.

1. CrestApps.AgentSkills — The Foundation

At the core of the ecosystem is:

CrestApps.AgentSkills

This is the foundational .NET project that defines reusable AI skills and the infrastructure to work with them.

It provides:

• A structured way to define AI agent skills
• Common abstractions for skill execution
• A shared engine that other packages build upon

This project is not OrchardCore-specific. It is designed for general .NET applications and acts as the base layer for everything else in the ecosystem.

If you are building AI-capable .NET applications and want a standardized way to define and organize skills, this is the starting point.

📦 Installation

Using the .NET CLI:

dotnet add package CrestApps.AgentSkills

Or using the Package Manager Console:

Install-Package CrestApps.AgentSkills

2. CrestApps.AgentSkills.Mcp — MCP Integration for .NET

Once skills are defined, they need to be discoverable and callable by external AI systems.

That is the role of:

CrestApps.AgentSkills.Mcp

This project integrates the core skill engine with the Model Context Protocol (MCP).

It enables:

• Exposure of registered skills through MCP
• Skill discovery by MCP-compatible clients
• Invocation of .NET skills via protocol calls

In practical terms, this allows your .NET application to act as an MCP server. External AI agents and tools that support MCP can inspect available skills and call them in a structured way.

This shifts AI integration from prompt-based guessing to protocol-driven interaction.

📦 Installation

Using the .NET CLI:

dotnet add package CrestApps.AgentSkills.Mcp

Or using the Package Manager Console:

Install-Package CrestApps.AgentSkills.Mcp

Note: This package depends on CrestApps.AgentSkills and will install it automatically if it is not already referenced.

3. CrestApps.AgentSkills.OrchardCore — OrchardCore-Specific Skills

For developers working with OrchardCore, the repository includes:

CrestApps.AgentSkills.OrchardCore

This project extends the core skill engine with OrchardCore-specific functionality.

It provides:

• OrchardCore-aware skill definitions
• Extensions tailored to CMS concepts
• Conventions for working with OrchardCore entities and structures

While the base package works for any .NET application, this project brings domain knowledge specific to OrchardCore into the skill system.

It enables AI skills that understand OrchardCore constructs rather than treating the CMS as a generic application.

📦 Installation

Using the .NET CLI:

dotnet add package CrestApps.AgentSkills.OrchardCore

Or using the Package Manager Console:

Install-Package CrestApps.AgentSkills.OrchardCore

Note: This package requires an OrchardCore application and depends on CrestApps.AgentSkills.

4. CrestApps.AgentSkills.Mcp.OrchardCore — OrchardCore MCP Runtime

Finally, the ecosystem includes:

CrestApps.AgentSkills.Mcp.OrchardCore

This package combines:

• OrchardCore-specific skills
• MCP server capabilities

It allows a running OrchardCore application to expose its skills through MCP at runtime.

With this in place, an OrchardCore instance can:

• Publish its available skills
• Respond to MCP calls from external agents
• Participate in a broader AI tooling ecosystem

This creates a bridge between a live CMS environment and AI agents that can interact with it programmatically.

📦 Installation

Using the .NET CLI:

dotnet add package CrestApps.AgentSkills.Mcp.OrchardCore

Or using the Package Manager Console:

Install-Package CrestApps.AgentSkills.Mcp.OrchardCore

Note: This package depends on:

• CrestApps.AgentSkills
• CrestApps.AgentSkills.Mcp
• CrestApps.AgentSkills.OrchardCore

All dependencies will be installed automatically by NuGet.

How the Projects Fit Together

The ecosystem is layered by design:

1. CrestApps.AgentSkills
   Core engine for defining and executing AI skills in .NET.

2. CrestApps.AgentSkills.Mcp
   Adds MCP protocol support to expose skills externally.

3. CrestApps.AgentSkills.OrchardCore
   Adds OrchardCore-specific skill definitions.

4. CrestApps.AgentSkills.Mcp.OrchardCore
   Hosts OrchardCore skills through MCP at runtime.

Each project builds directly on the previous layer, creating a clean separation of concerns.

Why This Architecture Matters

This ecosystem enables:

• Structured AI skill definitions instead of ad-hoc prompts
• Reusable skills across multiple projects
• Protocol-based integration using MCP
• Domain-aware AI capabilities for OrchardCore
• Runtime exposure of application capabilities to AI agents

For .NET developers, this means moving from experimental AI integrations to maintainable, discoverable, and extensible AI systems.

Final Thoughts

The CrestApps.AgentSkills ecosystem provides a practical foundation for building AI-capable .NET and OrchardCore applications using structured skills and the Model Context Protocol.

Instead of embedding AI logic directly into application code in an ad-hoc way, you get:

• A reusable skill engine
• A protocol bridge for external agents
• Domain-specific extensions
• A runtime hosting model

If you're building AI-driven .NET systems — especially with OrchardCore — this architecture offers a clean and scalable approach.

Context is everything.

Give an LLM a vague prompt, and you’ll get a vague response. But give it rich, structured, real-time context — and it becomes capable of surprising intelligence.

That’s the promise behind the Model Context Protocol (MCP) — and now, thanks to the CrestApps MCP Module, this power is available directly inside your OrchardCore applications.

Whether you're building a chatbot, a content assistant, or a smart dashboard, this new module makes it easy to extend AI behavior by plugging in external tools, services, and even your own backend logic — all without reinventing the wheel.

Let’s explore how MCP is changing the game for AI integrations and how you can get started today.

🤖 What is Model Context Protocol (MCP) and Why It’s a Game Changer

At its core, MCP is a simple but powerful idea: what if there was a universal way for AI models to talk to external systems?

Think of it like the USB-C for AI. With USB-C, you can connect your laptop to power, displays, or storage — no matter the brand. MCP works the same way for AI: it defines a standard protocol that lets large language models connect to tools, data, and services, no matter where they live.

So, what does MCP actually enable?

• 🧩 Pluggable Tools: Attach prebuilt tools like mcp/time, mcp/calc, or mcp/shell that run locally or in containers.
• 🌐 Real-Time Context: Provide your AI with live data from internal APIs, databases, or system commands.
• 🧠 Cross-Model Compatibility: Use the same tools across OpenAI, Ollama, Claude, and more.
• 🔒 Privacy & Control: Run tools locally or behind your firewall — no need to send data to the cloud.

It’s not just about better responses — it’s about making AI feel integrated into your app’s ecosystem, aware of your user, your data, and your environment.

Learn more: modelcontextprotocol.io/introduction

🧩 Extending OrchardCore AI with MCP

With the CrestApps AI Chat module, you already have a great foundation for building AI-powered experiences in OrchardCore. You can create profiles, hook into your preferred LLM provider, and start chatting with your model right away.

But let’s imagine a common scenario.

🧪 Real-World Example: Why Static AI Isn’t Enough

Let’s say you’ve created an AI profile that connects to your favorite LLM provider — great! Now you type something like:

“What is the current time in Bethlehem, Palestine?”

The model, however, responds with:

“I’m not sure — I don’t have access to real-time data.”

That’s because most language models — even the smartest ones — aren’t connected to the real world. They’re like extremely well-read introverts: lots of knowledge, no access to what’s happening right now.

This is where MCP comes to the rescue.

By connecting your OrchardCore AI profile to a remote or local MCP server — such as one that runs the mcp/time tool — your AI gains the ability to fetch real-time timezone information. The server does the lookup, returns the current time for Palestine, and the model weaves it into its answer naturally.

It feels like magic — but it’s just structured context delivered through MCP.

⚙️ Getting Started with the CrestApps MCP Module

The CrestApps.OrchardCore.AI.Mcp module extends the AI Chat capabilities by allowing your OrchardCore site to interact with MCP servers via:

• 🌐 Remote MCP Servers using Server-Sent Events (SSE)
• 🖥 Local MCP Tools via Standard Input/Output (Stdio)

To get started:

1. Install the CrestApps.OrchardCore.AI.Mcp NuGet package in your web project.
2. In the OrchardCore dashboard, go to Tools → Features
3. Enable one or both of:
   • Model Context Protocol (MCP) Client
   • Model Context Protocol (Local MCP) Client

🌐 Connecting to a Remote MCP Server (SSE Transport)

You can integrate any external MCP Server using Server-Sent Events (SSE), a lightweight, real-time communication method.

🛠 Step-by-Step:

1. Go to Artificial Intelligence → MCP Connections
2. Click Add Connection
3. Under SSE Source, click Add
4. Fill in details like:

Display Text: Remote AI Time Server
Endpoint: https://localhost:1234/
Additional Headers: (optional)

5. Click Save

🎯 Then go to AI Profiles and create a new profile using this connection.

🧾 Alternative: Recipe-Based Setup for Remote Server

You can also define the connection via a recipe file:

{
  "steps": [
    {
      "name": "McpConnection",
      "connections": [
        {
          "DisplayText": "Remote AI Tools",
          "Properties": {
            "SseMcpConnectionMetadata": {
              "Endpoint": "https://localhost:1234/",
              "AdditionalHeaders": {}
            }
          }
        }
      ]
    }
  ]
}

This is handy for multi-tenant solutions, automation, or CI/CD pipelines.

🖥 Using the Local MCP Client (Stdio Transport)

Want your AI to work offline or integrate with local tools? Use the Local MCP Client, which runs tools via standard input/output — especially useful with Dockerized tools like:

• 🕒 mcp/time (returns current time with time zone awareness)
• ➕ mcp/calc (evaluates math)
• 🖥 mcp/shell (secure command runner)

🧭 Example: Use mcp/time via Docker

Step 1: Install Docker Desktop

Download and install Docker Desktop if you haven't already.

Step 2: Pull the Image

docker pull mcp/time

Step 3: Add the Connection in OrchardCore

• Go to AI → MCP Connections
• Click Add Connection
• Choose Stdio Source and click Add
• Enter:

Display Text: Global Time Capabilities
Command: docker
Arguments: ["run", "-i", "--rm", "mcp/time"]

Click Save, and you’re ready to create a profile that uses this connection.

🧾 Recipe-Based Setup for Local Tools

Prefer automation? Here's how to configure the same connection via a recipe:

{
  "steps": [
    {
      "name": "McpConnection",
      "connections": [
        {
          "DisplayText": "Global Time Capabilities",
          "Properties": {
            "StdioMcpConnectionMetadata": {
              "Command": "docker",
              "Arguments": [
                "run",
                "-i",
                "--rm",
                "mcp/time"
              ]
            }
          }
        }
      ]
    }
  ]
}

🧠 More Creative Use Cases

Once MCP is connected, you can get creative with your AI tooling. Here are a few ideas:

• 🧮 Natural Language Calculator with mcp/calc
  Evaluate math queries like “What’s 25% of 480?”

• 📂 File Search Assistant using mcp/shell
  Help users locate files on disk using AI-generated search commands.

• 🕵️ Internal Monitoring Bot
  Connect to internal logs, status scripts, or diagnostic tools.

All of these can be exposed to your AI model using MCP’s consistent, secure protocol.

🌎 Where to Find MCP-Compatible Tools

MCP is growing fast. Explore these hubs for tools and servers:

• Docker Hub: MCP Tools
• MCP.so
• Glama.ai
• MCPServers.org

✅ Wrapping Up

The Model Context Protocol is redefining how AI applications get their context — and with the CrestApps MCP Module, that power is now available to OrchardCore developers with minimal setup and maximum flexibility.

Whether you're looking to add intelligence to your CMS, build AI-powered assistants, or just give your model access to real-world data — MCP offers a clean, scalable, and secure path forward.

Want to try it? 👉 Get started with the CrestApps MCP Module

Let me know if you'd like the Markdown version for publishing or want to add a diagram or code demo!

Artificial Intelligence (AI) is revolutionizing web applications by providing dynamic, intelligent interactions. In Orchard Core, AI capabilities can be extended beyond basic interactions by implementing custom functions that provide tailored responses and actions. This guide will walk you through extending AI models with functions using the CrestApps.OrchardCore.AI package.

Why Extend AI Models with Custom Functions?

AI models provide a strong foundation for chatbot interactions, but often, applications require specialized logic to fetch external data, perform calculations, or integrate with third-party services. By creating custom functions, developers can extend the AI's capabilities while keeping control over its behavior.

Some use cases for extending AI models with functions include:

• Retrieving real-time data (e.g., weather, stock prices, news updates).
• Integrating with APIs (e.g., CRM, inventory systems, support tickets).
• Performing complex computations (e.g., financial calculations, analytics processing).

Creating a Custom AI Function

The CrestApps.OrchardCore.AI package allows you to register custom functions that AI profiles can call when interacting with users. Here’s how you can create a simple function to fetch weather information based on a user’s location.

Step 1: Define the Function

To create a custom AI function, inherit from AIFunction and override its behavior:

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

    public GetWeatherFunction()
    {
        Name = TheName;
        Description = "Retrieves weather information for a specified location.";

        var metadata = new JsonObject()
        {
            {"type", "object"},
            {"properties", new JsonObject()
                {
                    { _locationProperty, new JsonObject()
                        {
                            {"type", "string" },
                            {"description", "The geographic location for which the weather information is requested." },
                        }
                    }
                }
            },
            {"required", new JsonArray(_locationProperty)},
            {"return_type", new JsonObject()
                {
                    {"type", "string"},
                    {"description", "The weather condition at the specified location."},
                }
            },
        };

        JsonSchema = JsonSerializer.Deserialize<JsonElement>(metadata);
    }

    public override string Name { get; }

    public override string Description { get; }

    public override JsonElement JsonSchema { get; }

    protected override Task<object> InvokeCoreAsync(IEnumerable<KeyValuePair<string, object>> arguments, CancellationToken cancellationToken)
    {
        var prompt = arguments.First(x => x.Key == _locationProperty).Value;

        string location = null;

        if (prompt is JsonElement jsonElement)
        {
            location = jsonElement.GetString();
        }
        else if (prompt is JsonNode jsonNode)
        {
            location = jsonNode.ToJsonString();
        }
        else if (prompt is string str)
        {
            location = str;
        }
        else
        {
            location = prompt?.ToString();
        }

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

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

Step 2: Register the Function

To make the function available in your AI setup, register it as a service in your Startup class:

services.AddAITool<GetWeatherFunction>(GetWeatherFunction.Name, options =>
{
    options.Title = "Weather Getter";
    options.Description = "Retrieves weather information for a specified location.";
});

This ensures that the AI service can access and use your custom function when processing user requests.

Using Custom Functions in AI Profiles

Once a function is registered, it can be used in AI profiles to extend chatbot capabilities.

1. Navigate to the AI Profiles Section in the Orchard Core dashboard.
2. Create or edit an existing AI profile.
3. Enable the custom function in the function list.
4. Test the function to ensure it responds correctly.

This allows AI-powered chatbots and automation workflows to utilize external data and provide smarter responses.

Example Use Case: AI-Driven Customer Support

Consider a scenario where a chatbot needs to provide real-time shipping status updates. By creating a custom function that fetches shipment details from an API, the AI can offer instant support to customers.

Example function:

public sealed class GetShippingStatusFunction : AIFunction
{
    private const string _trackingNumberProperty = "TrackingNumber";
    public const string TheName = "get_shipping_status";

    public GetShippingStatusFunction()
    {
        Name = TheName;
        Description = "Retrieves the current status of a shipment.";

        var metadata = new JsonObject()
        {
            {"type", "object"},
            {"properties", new JsonObject()
                {
                    { _trackingNumberProperty, new JsonObject()
                        {
                            {"type", "string" },
                            {"description", "The tracking number of the shipment." },
                        }
                    }
                }
            },
            {"required", new JsonArray(_trackingNumberProperty)},
            {"return_type", new JsonObject()
                {
                    {"type", "string"},
                    {"description", "The current shipment status."},
                }
            },
        };

        JsonSchema = JsonSerializer.Deserialize<JsonElement>(metadata);
    }

    public override string Name { get; }

    public override string Description { get; }

    public override JsonElement JsonSchema { get; }

    protected override async Task<object> InvokeCoreAsync(IEnumerable<KeyValuePair<string, object>> arguments, CancellationToken cancellationToken)
    {
        var prompt = arguments.First(x => x.Key == _trackingNumberProperty).Value;

        string trackingNumber = prompt?.ToString();
        string status = await FetchShippingStatusFromAPI(trackingNumber);

        return status;
    }

    private async Task<string> FetchShippingStatusFromAPI(string trackingNumber)
    {
        await Task.Delay(500);
        return $"Shipment {trackingNumber} is in transit.";
    }
}

Register the function as before and integrate it into your AI profile. Now, the chatbot can provide instant tracking updates!

Conclusion

Extending AI models with custom functions in Orchard Core enables developers to create more intelligent, data-driven chatbots and applications. By implementing and registering functions tailored to your needs, you can:

• Integrate AI with external APIs and data sources.
• Customize responses for specific business needs.
• Enhance chatbot functionalities with real-time insights.

Start extending your AI models today and unlock the full potential of AI-driven interactions in Orchard Core!

Additional Resources

• CrestApps.OrchardCore.AI Repository
• Orchard Core Documentation

Artificial Intelligence (AI) is transforming how web applications are developed and interacted with. As a .NET developer working with Orchard Core, you can enhance your applications by incorporating AI-driven functionalities. In this guide, we’ll walk you through integrating AI features into Orchard Core CMS using the CrestApps.OrchardCore.AI package and its implementations.

Prerequisites

Before you begin, ensure you have the following:

• An Orchard Core CMS project set up and running.
• A basic understanding of NuGet and Orchard Core’s module system.
• Access to Azure OpenAI, DeepSeek, or another supported AI provider.

Step 1: Install the AI Services Module

The AI Services module provides the foundational infrastructure for AI integration in Orchard Core.

Installation Steps (With User Interface)

1. Open your Orchard Core web project in Visual Studio or your preferred IDE.
2. Install the CrestApps.OrchardCore.AI.Chat package using NuGet:

   Install-Package CrestApps.OrchardCore.AI.Chat
   

3. Once installed, a new Artificial Intelligence menu item will appear in Orchard Core, along with a Profiles submenu.

Here is a sneek peak of the Chat-UI using the backend

<img src="https://github.com/CrestApps/CrestApps.OrchardCore/blob/main/docs/images/admin-ui-sample.gif" class="img-fluid" alt="AI Chat using the OrchardCore's backend" />

Here is a sneek peak of the Chat-UI using the frontend Widget

<img src="https://github.com/CrestApps/CrestApps.OrchardCore/blob/main/docs/images/admin-ui-sample.gif" class="img-fluid" alt="AI Chat using the OrchardCore's frontend widget" />

Installation Steps (With no User Interface)

1. Open your Orchard Core web project in Visual Studio or your preferred IDE.
2. Install the CrestApps.OrchardCore.AI package using NuGet:

   Install-Package CrestApps.OrchardCore.AI
   

3. Once installed, a new Artificial Intelligence menu item will appear in Orchard Core, along with a Profiles submenu.

Step 2: Understanding AI Profiles

An AI Profile defines how the chatbot interacts with users. The module supports three profile types:

• Chat: A fully interactive chatbot for multi-turn conversations.
• Utility: Provides one-time responses, useful for workflow automation.
• Template Generated Prompt: Uses Liquid syntax to create dynamic prompts, ideal for content summarization and structured responses.

You can configure AI Profiles within the Orchard Core Dashboard to customize chatbot behavior according to your needs.

Step 3: Choose Your AI Implementation

The CrestApps.OrchardCore.AI module is flexible and supports multiple AI providers, including:

• Azure OpenAI
• DeepSeek
• OpenAI
• Ollama (for local testing)
• Azure AI Inference

Below, we explore the primary implementations and their configurations.

Azure OpenAI Integration

Install the Module

Use NuGet to install the Azure OpenAI module:

Install-Package CrestApps.OrchardCore.OpenAI.Azure

Configure Azure OpenAI

Modify appsettings.json to establish a connection with Azure OpenAI:

{
  "OrchardCore": {
    "CrestApps_AI": {
      "Providers": {
        "Azure": {
          "DefaultConnectionName": "your-connection-name",
          "DefaultDeploymentName": "your-deployment-name",
          "Connections": {
            "your-connection-name": {
              "Endpoint":"https://<!-- Your Azure Resource Name -->.openai.azure.com/",
              "AuthenticationType": "ApiKey",
              "ApiKey":"<!-- API Key to connect to your Azure AI instance -->",
              "DefaultDeploymentName": "the default deployment name for this connection"
            }
          }
        }
      }
    }
  }
}

Enable Azure OpenAI Features

1. Enable the Azure OpenAI Chat feature in the Orchard Core Dashboard.
2. Create an AI Profile and select Azure OpenAI as the provider.
3. If using Chat with Your Data, configure Azure AI Search for custom datasets.

With Azure OpenAI, you can create intelligent chatbots, automate customer support, and enhance user interactions effortlessly.

OpenAI Integration

Install the Module

Install-Package CrestApps.OrchardCore.OpenAI

Configure OpenAI

Configure the settings using any settings provider. To configure the service with DeepSeek credentials using appsettings.json:

{
  "OrchardCore": {
    "CrestApps_AI": {
      "Providers": {
        "OpenAI": {
          "DefaultConnectionName": "openai-cloud",
          "DefaultDeploymentName": "gpt-4o-mini",
          "Connections": {
            "openai-cloud": {
              "ApiKey": "your-openai-api-key",
              "DefaultDeploymentName": "gpt-4o-mini",
            }
          }
        }
      }
    }
  }
}

To obtain an API key, visit the OpenAI Platform.

Enable OpenAI in Orchard Core

1. Enable OpenAI Chat feature in the Orchard Core Dashboard.
2. Navigate to Artificial Intelligence > Profiles and create a new AI Profile.
3. Select OpenAI as the AI provider, configure the settings, and save.

Once set up, your DeepSeek AI chatbot will be available in Orchard Core.

DeepSeek Integration

The AI module allows seamless integration with any provider that follows OpenAI standards. DeepSeek is one such provider, offering an API compatible with OpenAI. This compatibility enables effortless connection using OpenAI's interface. First be sure to following "OpenAI Integration" section above. Then to configure the settings using any settings provider. To configure the service with DeepSeek credentials using appsettings.json:

{
  "OrchardCore": {
    "CrestApps_AI": {
      "Providers": {
        "OpenAI": {
          "DefaultConnectionName": "deepseek-cloud",
          "DefaultDeploymentName": "deepseek-chat",
          "Connections": {
            "deepseek": {
              "Endpoint": "https://api.deepseek.com/v1",
              "ApiKey": "your-deepseek-api-key",
              "DefaultDeploymentName": "deepseek-chat"
            }
          }
        }
      }
    }
  }
}

Other AI Implementations

CrestApps also provides implementations for:

• Azure AI Inference
• Ollama (for local testing)

You may look at the documentation in the repository for more info: https://github.com/CrestApps/CrestApps.OrchardCore

Managing Provider Connections

The AI module includes an AI Connection Management feature that allows you to manage provider connections through the user interface at the tenant level, instead of relying on the appsettings.json file, which applies to all tenants.

To get started, first enable the AI Connection Management feature, then follow these steps:

Enabling AI Connection Management

1. In the Orchard Core Dashboard, enable the AI Connection Management feature.
2. Navigate to Artificial Intelligence > Connections and create a new provider connection.
3. Choose your preferred provider, configure the necessary settings, and save.

Once set up, the connection will be available for use with any of your AI profiles.

Extending AI Models with Custom Functions in Orchard Core

Want to see how easy it is to add custom functions? Click here to read the full article.

Conclusion

Integrating AI into Orchard Core is now easier than ever with the CrestApps AI package. Whether you opt for Azure OpenAI for enterprise-grade AI services or DeepSeek for flexible AI interactions, you can enhance your CMS with intelligent chatbot solutions and AI-driven workflows.

By following this guide, you can quickly configure AI services in Orchard Core and unlock innovative functionalities for your applications. Start exploring AI capabilities today and transform how users interact with your platform!

Additional Resources

• CrestApps GitHub
• Extending AI Models with Custom Functions
• Orchard Core Documentation
• Azure OpenAI Documentation
• DeepSeek Platform
• OpenAI Platform

What is DeepSeek?

DeepSeek is a powerful AI platform that provides developers with access to advanced language models, enabling them to build intelligent applications with ease. Whether you’re looking to enhance your app with natural language processing, reasoning capabilities, or conversational AI, DeepSeek has you covered.

What sets DeepSeek apart is its compatibility with OpenAI’s API standards, making it incredibly easy for developers to integrate into their existing workflows. With DeepSeek, you can leverage state-of-the-art AI models like deepseek-chat and deepseek-reasoner to create smarter, more responsive applications.

How Can We Benefit from It?

DeepSeek empowers developers to build AI-driven features without needing to dive deep into the complexities of machine learning. Here are some ways you can benefit from using DeepSeek:

1. Enhanced User Experiences: Integrate conversational AI into your apps to provide users with intuitive, natural language interactions.
2. Improved Productivity: Automate repetitive tasks like code generation, documentation, or data analysis using AI-powered tools.
3. Cost-Effective AI Solutions: DeepSeek offers competitive pricing and flexible models, making advanced AI accessible to developers of all levels.
4. OpenAI Compatibility: If you’re already familiar with OpenAI’s API, integrating DeepSeek into your projects will feel like second nature.

By leveraging DeepSeek, you can focus on building innovative features while leaving the heavy lifting of AI to the platform.

How Can We Interact with It Using C#?

Thanks to Microsoft’s efforts, interacting with AI services like DeepSeek is incredibly straightforward. If you’re a C# developer, you can use the Microsoft.Extensions.AI.OpenAI library to interact with DeepSeek’s API. Here’s how you can get started:

Step 1: Create an API Key

To begin, you’ll need an API key from DeepSeek. Visit https://platform.deepseek.com/api_keys, create an account, and generate a new API key.

Step 2: Install the Required NuGet Package

Install the Microsoft.Extensions.AI.OpenAI package using the NuGet Package Manager or run the following command in the Package Manager Console:

Install-Package Microsoft.Extensions.AI.OpenAI

Step 3: Set Up the Chat Client

Once you’ve installed the package, you can create a chat client to interact with DeepSeek’s models. Here’s an example of how to set it up:

private IChatClient GetChatClient(string apiKey, string modelId)
{
    var client = new OpenAIClient(new ApiKeyCredential(apiKey), new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://api.deepseek.com/v1"),
    });

    var builder = new ChatClientBuilder(client.AsChatClient(modelId));

    if (modelId != "deepseek-reasoner")
    {
        // The 'deepseek-reasoner' model does not support tool calling.
        builder.UseFunctionInvocation(null, (r) =>
        {
            // Set the maximum number of iterations per request to 1 to prevent infinite function calling.
            r.MaximumIterationsPerRequest = 1;
        });
    }

    return builder.Build();
}

Step 4: Call the DeepSeek API

With the chat client set up, you can now call the DeepSeek API to generate responses. Here’s an example:

var chatClient = GetChatClient("your-api-key", "deepseek-chat");

var prompts = new List<ChatMessage>
{
    new(ChatRole.User, "What is Orchard Core?"),
};

var result = await chatClient.CompleteAsync(prompts);

foreach (var choice in result.Choices)
{
    Console.WriteLine(choice.Text);
}

Supported Models

As of this blog post, DeepSeek supports two models:

• deepseek-chat: Ideal for conversational AI and natural language interactions.
• deepseek-reasoner: Designed for more complex reasoning tasks.

Unlock the Power of AI in Your .NET Project Using OrchardCore CMS

Looking for an easy way to integrate AI into your ASP.NET project using the amazing OrchardCore CMS? Visit Integrating AI Features into Your Orchard Core Project: A Guide for .NET Developers for a step-by-step guide to unlocking the power of AI in your own .NET project.

It’s That Simple!

Integrating DeepSeek into your C# and .NET applications is a breeze, thanks to its compatibility with OpenAI’s API standards and the Microsoft.Extensions.AI.OpenAI library. Whether you’re building a chatbot, automating tasks, or enhancing your app with AI, DeepSeek provides the tools you need to succeed.

In this series of posts, I’ll guide you through key concepts in Orchard Core, helping you understand how to excel as an Orchard Core developer. We'll compare how things are done in a standard MVC project and how to achieve the same results using Orchard Core. By the end of the series, you should be comfortable with Orchard Core's unique concepts and how to navigate its UI.

Create, Read, Update, and Delete (CRUD) Operations from an MVC Developer's Perspective

CRUD operations are essential in any application. In an ASP.NET MVC app, we typically:

1. Create a model to represent the data.
2. Define actions for each operation (Create, Read, Update, Delete).
3. Add views and view-models for each action.

Example: Creating a Person Model

For instance, let's assume we want to build a small app to capture basic information about people. We would start by creating a Person model like this:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Biography { get; set; }
    public string AddressLine1 { get; set; }
    public string AddressLine2 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string PostalCode { get; set; }
}

Next, we add actions (such as Create, Edit, Delete) to the PersonController and create the corresponding views and view-models.

Example: PersonViewModel

To allow users to select a state from a dropdown, we might create a view-model:

public class PersonViewModel
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Biography { get; set; }
    public string AddressLine1 { get; set; }
    public string AddressLine2 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string PostalCode { get; set; }

    // A collection to render a list of states the user can select from.
    [BindNever]
    public IEnumerable<SelectListItem> States { get; set; }
}

Creating and maintaining such an app can be time-consuming. Now, let’s explore how to achieve the same functionality using Orchard Core.

Content Types in Orchard Core

A foundational element of Orchard Core is content types. These are customizable data structures that define how content is organized and displayed. Content types allow you to create different kinds of content, such as blog posts, pages, or products, with specific fields and behaviors.

Think of a model class in standard development as a Content Type in Orchard Core, and each property of the class as a Content Field.

Creating a Content Type in Orchard Core

To create a Person content type:

1. Ensure the Content Types feature is enabled.
2. In the dashboard, go to Content → Content Types.
3. Click Add to create a new content type.
4. Name it Person (the technical name will be generated automatically).

Once created, you can edit the content type and add fields to it.

Content Fields

In Orchard Core, we use content fields to define the data we want to collect. To add fields to the Person content type:

1. Enable the Content Fields feature (if not already enabled).
2. Navigate to the Person content type and click Edit.
3. Add the necessary fields (e.g., FirstName, LastName, Biography, etc.) by selecting the appropriate field types (e.g., TextField for string data).

For a detailed list of available content fields, check out the Orchard Core Documentation on Content Fields.

Content Items

In a standard MVC app, once we create a model class, we instantiate it and save it to the database. In Orchard Core, the equivalent of a model instance is a content item.

To create a content item:

1. Ensure the Contents feature is enabled.
2. In the dashboard, go to Content → Content Items.
3. Click the Add button and select the Person content type.
4. Fill out the form with the data and click Publish.

This process completes the basic CRUD operation in Orchard Core, which is simple and elegant.

Configuring Content Fields

If the default field appearance doesn’t meet your needs, you can configure the field settings. For example:

• Make a field required.
• Change a field to a dropdown or multi-line input.

Configuring the FirstName Field as Required

To make the FirstName field required:

1. Go to Content → Content Types.
2. Edit the Person content type.
3. In the fields section, click Edit next to FirstName.
4. Check the Required box and save the changes.

Now, if you try to publish a content item without providing a first name, Orchard Core will show an error message.

Field Editors

Field editors allow you to change the way data is captured in the UI. For example:

• The TextField can have different editors, such as single-line, multi-line, or a picklist.

Changing the Biography Field Editor

1. Go to the Biography field in the Person content type.
2. Change the editor to Multi-Line and save the settings.

Similarly, you can change the State field editor to PickList, allowing users to select from predefined values.

Content Parts: Reusable Data Structures

What if your business needs change? For example, you might want to create a Customer content type that only requires FirstName and LastName but not the address fields. Instead of adding these fields manually to each content type, you can use content parts.

A content part is a reusable set of fields. For instance, you could create a PersonInfoPart containing FirstName and LastName and attach it to multiple content types (e.g., Person, Employee, Customer).

Creating a Content Part

1. Go to Content → Content Parts.
2. Click Add and name the part PersonInfoPart.
3. Add FirstName and LastName fields and configure them as required.
4. Save the content part.

Now, to attach this part to the Person content type, simply:

1. Edit the Person content type.
2. Remove the existing FirstName and LastName fields.
3. Under Fields, click Add Part and select PersonInfoPart.
4. Save the changes.

Now, you have a reusable part that can be attached to any content type. If you modify the part, the changes will be reflected across all content types it’s attached to.

Making Content Parts Reusable

By checking the Reusable checkbox when creating a content part, you allow it to be attached multiple times to the same content type. This is useful if, for example, you need to capture both an employee’s and their spouse’s information.

Conclusion

In this post, we learned about Content Types, Content Fields, and Content Parts in Orchard Core. We covered how to use these components, configure them, and navigate the UI to create a simple CRUD application.

If you found this post helpful, please share it to help others discover Orchard Core!