How to Use OpenAI Embeddings in a .NET Project?

Introduction

OpenAI embeddings allow developers to convert text into numerical vectors that represent semantic meaning. These vectors can then be used for semantic search, similarity comparison, recommendation systems, chatbots, and Retrieval-Augmented Generation (RAG) applications. In a modern .NET project such as an ASP.NET Core Web API or background service, OpenAI embeddings are commonly used with vector databases to build intelligent AI-powered features.

This guide explains in simple language how to use OpenAI embeddings in a .NET project, including setup, code implementation, and best practices for production-ready enterprise applications.

What Are OpenAI Embeddings?

Embeddings are high-dimensional numeric representations of text. Instead of comparing words directly, embeddings compare meaning.

For example:

"How to reset my password?"
"I forgot my login credentials"

Even though the wording is different, embeddings allow AI systems to understand that both sentences have similar intent.

In enterprise AI applications, embeddings are used for:

Semantic search in large document collections
Knowledge base chatbots
Document similarity matching
AI-powered recommendations
Fraud detection and analytics

Prerequisites for Using OpenAI Embeddings in .NET

Before integrating OpenAI embeddings in your .NET project, ensure you have:

A .NET SDK installed
An OpenAI API key
An ASP.NET Core or Console application
Basic understanding of dependency injection and HTTP clients

Always store your API key securely using environment variables or a secret manager.

Step 1: Create a .NET Project

Create a new ASP.NET Core Web API or Console project:

dotnet new webapi -n EmbeddingDemo
cd EmbeddingDemo

Or for a console app:

dotnet new console -n EmbeddingDemo

Step 2: Store Your OpenAI API Key Securely

Add your API key to environment variables (recommended for production):

Windows:

setx OPENAI_API_KEY "your_api_key_here"

In ASP.NET Core, you can read it like this:

var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");

Never hardcode API keys inside your source code.

Step 3: Register HttpClient in ASP.NET Core

Inside Program.cs:

builder.Services.AddHttpClient("OpenAI", client =>
{
    client.BaseAddress = new Uri("https://api.openai.com/v1/");
    client.DefaultRequestHeaders.Add("Authorization",
        $"Bearer {Environment.GetEnvironmentVariable("OPENAI_API_KEY")}");
});

Using IHttpClientFactory ensures better performance and prevents socket exhaustion in cloud-native .NET applications.

Step 4: Create an Embedding Service

Create a service class to generate embeddings.

public class EmbeddingService
{
    private readonly HttpClient _httpClient;

    public EmbeddingService(IHttpClientFactory factory)
    {
        _httpClient = factory.CreateClient("OpenAI");
    }

    public async Task<float[]> GenerateEmbeddingAsync(string inputText)
    {
        var requestBody = new
        {
            model = "text-embedding-3-small",
            input = inputText
        };

        var response = await _httpClient.PostAsJsonAsync("embeddings", requestBody);

        response.EnsureSuccessStatusCode();

        var result = await response.Content.ReadFromJsonAsync<dynamic>();

        return ((IEnumerable<object>)result.data[0].embedding)
            .Select(x => Convert.ToSingle(x))
            .ToArray();
    }
}

builder.Services.AddScoped<EmbeddingService>();

This method sends text to OpenAI and returns a vector embedding.

Step 5: Use Embeddings for Semantic Search

Once you generate embeddings, you can:

Store them in a vector database
Compare similarity using cosine similarity
Perform semantic search

Example similarity calculation in C#:

public static double CosineSimilarity(float[] vector1, float[] vector2)
{
    double dotProduct = 0.0;
    double magnitude1 = 0.0;
    double magnitude2 = 0.0;

    for (int i = 0; i < vector1.Length; i++)
    {
        dotProduct += vector1[i] * vector2[i];
        magnitude1 += Math.Pow(vector1[i], 2);
        magnitude2 += Math.Pow(vector2[i], 2);
    }

    magnitude1 = Math.Sqrt(magnitude1);
    magnitude2 = Math.Sqrt(magnitude2);

    return dotProduct / (magnitude1 * magnitude2);
}

Higher similarity score means more similar meaning.

Integrating with a Vector Database

In real-world enterprise AI applications, embeddings are stored in a vector database such as:

Azure AI Search
Pinecone
Weaviate
Milvus

When a user asks a question:

Convert the question into an embedding.
Search the vector database for similar vectors.
Retrieve relevant documents.
Use those documents in a RAG-based AI response.

This architecture is widely used in AI-powered knowledge management systems and cloud-native AI applications.

Best Practices for Production .NET Applications

Use IHttpClientFactory for HTTP calls
Implement retry policies with Polly
Cache embeddings for repeated content
Secure API keys using Azure Key Vault or environment variables
Monitor API usage and rate limits
Validate input before sending to OpenAI

Following these best practices ensures a scalable and secure AI integration in ASP.NET Core applications.

Common Issues When Using OpenAI Embeddings

Incorrect API key configuration
Exceeding token limits
High latency without caching
Large documents without chunking
Not normalizing vectors before similarity comparison

Proper error handling and logging help troubleshoot embedding-related problems.

Summary

Using OpenAI embeddings in a .NET project involves securely configuring your API key, sending text to the OpenAI embeddings endpoint, receiving numerical vector representations, and using those vectors for semantic search, similarity matching, or Retrieval-Augmented Generation systems. By integrating embeddings with ASP.NET Core, IHttpClientFactory, and vector databases, developers can build scalable, cloud-native, and enterprise-ready AI applications that provide accurate and context-aware results. Proper security, caching, and monitoring practices ensure reliable performance in production environments.