Vector Databases & Embeddings - LangChain Tutorial | TechLead

What Are Embeddings?

Embeddings are numerical representations of text (or images, audio, etc.) as vectors — arrays of floating-point numbers that capture semantic meaning. Texts with similar meaning have vectors that are close together in the vector space, enabling semantic search.

🧮 Why Embeddings Matter

Semantic Search: Find content by meaning, not just keyword matching
RAG Foundation: Embeddings power Retrieval-Augmented Generation
Similarity: Compare documents, find duplicates, cluster content
Recommendation: Build recommendation systems based on content similarity

Generating Embeddings with LangChain

LangChain provides a unified interface for generating embeddings from multiple providers.

import { OpenAIEmbeddings } from "@langchain/openai";

// Initialize embeddings model
const embeddings = new OpenAIEmbeddings({
  modelName: "text-embedding-3-small", // Fast and affordable
  // modelName: "text-embedding-3-large", // Higher quality
});

// Generate embedding for a single text
const vector = await embeddings.embedQuery(
  "What is machine learning?"
);
console.log(vector.length); // 1536 dimensions
console.log(vector.slice(0, 5)); // [0.012, -0.034, 0.089, ...]

// Generate embeddings for multiple texts at once
const vectors = await embeddings.embedDocuments([
  "Machine learning is a subset of AI",
  "React is a JavaScript library",
  "Docker runs containers",
]);
console.log(vectors.length); // 3

What Is a Vector Database?

A vector database is a specialized database designed to store and query high-dimensional vectors efficiently. Unlike traditional databases that search by exact matches, vector databases find the most similar vectors using distance metrics like cosine similarity or Euclidean distance.

Vector Database	Type	Best For	Free Tier
Pinecone	Managed cloud	Production, scale	✅ Yes
Chroma	Open-source	Local dev, prototyping	✅ Free
Supabase pgvector	PostgreSQL extension	Full-stack apps	✅ Yes
Weaviate	Open-source / Cloud	Multi-modal search	✅ Yes
Qdrant	Open-source / Cloud	Filtering + search	✅ Yes
MemoryVectorStore	In-memory	Testing, small datasets	✅ Built-in

In-Memory Vector Store (Quick Start)

LangChain's built-in MemoryVectorStore is perfect for learning and prototyping — no external database needed.

import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { OpenAIEmbeddings } from "@langchain/openai";
import { Document } from "@langchain/core/documents";

// Create documents
const documents = [
  new Document({
    pageContent: "LangChain is a framework for building LLM apps",
    metadata: { source: "docs", topic: "langchain" },
  }),
  new Document({
    pageContent: "React is a library for building user interfaces",
    metadata: { source: "docs", topic: "react" },
  }),
  new Document({
    pageContent: "Vector databases store embeddings for similarity search",
    metadata: { source: "docs", topic: "vectors" },
  }),
  new Document({
    pageContent: "Docker containers package applications with dependencies",
    metadata: { source: "docs", topic: "docker" },
  }),
];

// Create vector store from documents
const vectorStore = await MemoryVectorStore.fromDocuments(
  documents,
  new OpenAIEmbeddings()
);

// Similarity search — finds semantically similar documents
const results = await vectorStore.similaritySearch(
  "How do I build AI applications?", // Query
  2 // Return top 2 results
);

console.log(results[0].pageContent);
// "LangChain is a framework for building LLM apps"
console.log(results[0].metadata);
// { source: "docs", topic: "langchain" }

Using Pinecone

Pinecone is a managed vector database ideal for production use cases with millions of vectors.

# Install Pinecone integration
npm install @pinecone-database/pinecone @langchain/pinecone

import { Pinecone } from "@pinecone-database/pinecone";
import { PineconeStore } from "@langchain/pinecone";
import { OpenAIEmbeddings } from "@langchain/openai";

// Initialize Pinecone
const pinecone = new Pinecone({
  apiKey: process.env.PINECONE_API_KEY!,
});

const index = pinecone.Index("my-index");

// Create vector store from existing index
const vectorStore = await PineconeStore.fromExistingIndex(
  new OpenAIEmbeddings(),
  { pineconeIndex: index }
);

// Add documents
await vectorStore.addDocuments([
  new Document({
    pageContent: "Next.js supports server-side rendering",
    metadata: { category: "frameworks" },
  }),
]);

// Search with metadata filtering
const results = await vectorStore.similaritySearch(
  "server rendering frameworks",
  3,
  { category: "frameworks" } // Filter by metadata
);

Using Supabase pgvector

Use Supabase with pgvector to keep your vector search in the same database as your app data.

import { SupabaseVectorStore } from "@langchain/community/vectorstores/supabase";
import { OpenAIEmbeddings } from "@langchain/openai";
import { createClient } from "@supabase/supabase-js";

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_KEY!
);

// Create vector store
const vectorStore = new SupabaseVectorStore(
  new OpenAIEmbeddings(),
  {
    client: supabase,
    tableName: "documents",
    queryName: "match_documents",
  }
);

// Add documents — automatically generates embeddings
await vectorStore.addDocuments([
  new Document({ pageContent: "Supabase is an open-source Firebase alternative" }),
  new Document({ pageContent: "pgvector enables vector search in PostgreSQL" }),
]);

// Similarity search
const results = await vectorStore.similaritySearch(
  "open source backend platform", 3
);

Similarity Search with Scores

Get similarity scores alongside results to filter by relevance threshold.

// Returns [Document, score] tuples
const resultsWithScores = await vectorStore.similaritySearchWithScore(
  "How do I deploy a web app?",
  5
);

for (const [doc, score] of resultsWithScores) {
  console.log(`Score: ${score.toFixed(4)} | ${doc.pageContent}`);
}
// Score: 0.9234 | Deploy web apps with Docker and Kubernetes
// Score: 0.8912 | Use Vercel for frontend deployments
// Score: 0.7456 | CI/CD pipelines automate deployment

// Filter by minimum relevance score
const relevant = resultsWithScores.filter(
  ([_, score]) => score > 0.8
);

Using as a Retriever in RAG

Convert any vector store into a retriever for use in RAG chains.

import { ChatOpenAI } from "@langchain/openai";
import { createRetrievalChain } from "langchain/chains/retrieval";
import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
import { ChatPromptTemplate } from "@langchain/core/prompts";

// Convert vector store to retriever
const retriever = vectorStore.asRetriever({
  k: 4, // Return top 4 documents
  searchType: "similarity", // or "mmr" for diversity
});

// Create a RAG chain
const prompt = ChatPromptTemplate.fromTemplate(`
Answer the question based on the following context:

Context: {context}

Question: {input}

Answer:`);

const documentChain = await createStuffDocumentsChain({
  llm: new ChatOpenAI({ modelName: "gpt-4" }),
  prompt,
});

const retrievalChain = await createRetrievalChain({
  combineDocsChain: documentChain,
  retriever,
});

const response = await retrievalChain.invoke({
  input: "How do I deploy with Docker?",
});
console.log(response.answer);

💡 Key Takeaways

• Embeddings convert text into numerical vectors that capture semantic meaning
• Vector databases enable fast similarity search across millions of vectors
• MemoryVectorStore is great for prototyping; use Pinecone/Supabase for production
• Use .asRetriever() to connect vector stores to RAG chains
• Similarity scores help filter results by relevance threshold