Integrating OpenAI / ChatGPT in ASP.NET Core Web API

 This guide shows how to build a production-ready AI API using ASP.NET Core with: Clean Architecture, streaming responses, database storage, and secure configuration.

---

🏗️ Architecture Overview

API Layer → Application Layer → Infrastructure Layer → Database

• API: Controllers
• Application: Business logic
• Infrastructure: OpenAI + DB
• Database: Chat history

---

1. Secure Configuration (Environment Variable)

builder.Configuration.AddEnvironmentVariables();

var apiKey = builder.Configuration["OPENAI_API_KEY"];

⚠️ Never store API keys in appsettings.json in production.

---

2. Database Model (Chat History)

public class ChatMessage
{
    public int Id { get; set; }
    public string UserMessage { get; set; }
    public string BotResponse { get; set; }
    public DateTime CreatedAt { get; set; }
}

---

3. DbContext (EF Core)

public class AppDbContext : DbContext
{
    public DbSet<ChatMessage> ChatMessages { get; set; }

    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) { }
}

---

4. OpenAI Service (Production Ready)

public class OpenAIService
{
    private readonly HttpClient _httpClient;
    private readonly IConfiguration _config;

    public OpenAIService(HttpClient httpClient, IConfiguration config)
    {
        _httpClient = httpClient;
        _config = config;
    }

    public async Task<string> GetResponseAsync(string prompt)
    {
        var request = new
        {
            model = "gpt-4o-mini",
            messages = new[]
            {
                new { role = "user", content = prompt }
            }
        };

        _httpClient.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Bearer", _config["OPENAI_API_KEY"]);

        var response = await _httpClient.PostAsJsonAsync(
            "https://api.openai.com/v1/chat/completions", request);

        if (!response.IsSuccessStatusCode)
            throw new Exception("OpenAI API error");

        var result = await response.Content.ReadFromJsonAsync<dynamic>();
        return result.choices[0].message.content;
    }
}

---

5. Streaming Response (Real-Time)

[HttpPost("stream")]
public async Task Stream([FromBody] string prompt)
{
    Response.ContentType = "text/plain";

    var response = await _service.GetResponseAsync(prompt);

    foreach (var word in response.Split(" "))
    {
        await Response.WriteAsync(word + " ");
        await Response.Body.FlushAsync();
        await Task.Delay(50);
    }
}

✅ Simulates real-time typing (like ChatGPT)

---

6. Save Chat History

public async Task SaveChat(string userMsg, string botMsg)
{
    var chat = new ChatMessage
    {
        UserMessage = userMsg,
        BotResponse = botMsg,
        CreatedAt = DateTime.UtcNow
    };

    _context.ChatMessages.Add(chat);
    await _context.SaveChangesAsync();
}

---

7. Controller (Final Version)

[ApiController]
[Route("api/chat")]
public class ChatController : ControllerBase
{
    private readonly OpenAIService _service;
    private readonly AppDbContext _context;

    public ChatController(OpenAIService service, AppDbContext context)
    {
        _service = service;
        _context = context;
    }

    [HttpPost]
    public async Task<IActionResult> Ask(string prompt)
    {
        var response = await _service.GetResponseAsync(prompt);

        await _context.ChatMessages.AddAsync(new ChatMessage
        {
            UserMessage = prompt,
            BotResponse = response,
            CreatedAt = DateTime.UtcNow
        });

        await _context.SaveChangesAsync();

        return Ok(response);
    }
}

---

8. Logging (Serilog)

builder.Host.UseSerilog((ctx, lc) =>
    lc.WriteTo.Console()
);

---

9. Rate Limiting

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("api", opt =>
    {
        opt.PermitLimit = 50;
        opt.Window = TimeSpan.FromMinutes(1);
    });
});

---

🔐 Enterprise Best Practices

• Use Redis for caching responses
• Store chat history per user
• Use JWT authentication
• Add retry policy (Polly)
• Use Azure Key Vault
• Implement circuit breaker

---

💡 Real Product Ideas

• AI Customer Support API
• WhatsApp Auto Reply Bot
• AI Code Review Tool
• Content Generator SaaS

---

📌 Conclusion

You now have a complete enterprise-grade AI API using ASP.NET Core. This can be extended into a scalable SaaS product.

How to Improve API Performance in ASP.NET Core

Performance is critical for modern APIs. A slow API leads to poor user experience and scalability issues. In this article, we will explore proven techniques to improve API performance in ASP.NET Core with real examples.

---

1. Use Asynchronous Programming

Always use async/await for I/O operations to avoid blocking threads.

[HttpGet]
public async Task GetUsers()
{
    var users = await _context.Users.ToListAsync();
    return Ok(users);
}

Benefit: Improves scalability and thread utilization.

---

2. Enable Response Caching

Caching reduces repeated processing and database calls.

[HttpGet]
[ResponseCache(Duration = 60)]
public IActionResult GetData()
{
    return Ok("Cached Data");
}

Also enable in Program.cs:

builder.Services.AddResponseCaching();

app.UseResponseCaching();

---

3. Use In-Memory Caching

public class UserService
{
    private readonly IMemoryCache _cache;

    public UserService(IMemoryCache cache)
    {
        _cache = cache;
    }

    public async Task> GetUsers()
    {
        if (!_cache.TryGetValue("users", out List users))
        {
            users = await _context.Users.ToListAsync();

            _cache.Set("users", users, TimeSpan.FromMinutes(5));
        }

        return users;
    }
}

---

4. Optimize Database Queries

Use projection instead of fetching full entities.

var users = await _context.Users
    .Select(u => new { u.Id, u.Name })
    .ToListAsync();

Use AsNoTracking() for read-only queries:

var users = await _context.Users
    .AsNoTracking()
    .ToListAsync();

---

5. Use Pagination

[HttpGet]
public async Task GetUsers(int page = 1, int pageSize = 10)
{
    var users = await _context.Users
        .Skip((page - 1) * pageSize)
        .Take(pageSize)
        .ToListAsync();

    return Ok(users);
}

---

6. Enable Compression

Reduces response size.

builder.Services.AddResponseCompression();

app.UseResponseCompression();

---

7. Use Minimal APIs (Faster Execution)

app.MapGet("/users", async (AppDbContext db) =>
{
    return await db.Users.ToListAsync();
});

---

8. Avoid Blocking Calls

❌ Bad Practice:

var data = _service.GetData().Result;

✅ Good Practice:

var data = await _service.GetData();

---

9. Use Connection Pooling

Configured automatically in EF Core, but ensure proper DB connection string usage.

"ConnectionStrings": {
  "DefaultConnection": "Server=.;Database=TestDb;Trusted_Connection=True;Pooling=true;"
}

---

10. Use Logging & Monitoring

Use tools like Application Insights or Serilog.

builder.Logging.ClearProviders();
builder.Logging.AddConsole();

---

11. Use Rate Limiting

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("fixed", opt =>
    {
        opt.PermitLimit = 100;
        opt.Window = TimeSpan.FromMinutes(1);
    });
});

app.UseRateLimiter();

---

12. Use Background Tasks for Heavy Work

Offload heavy tasks using background services.

public class BackgroundJob : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Background work
            await Task.Delay(1000);
        }
    }
}

---

📌 Conclusion

Improving API performance in ASP.NET Core requires a combination of best practices:

• Use async programming
• Apply caching strategies
• Optimize database queries
• Enable compression
• Avoid unnecessary data processing

By applying these techniques, you can significantly improve your API speed, scalability, and user experience.