{"slug": "sql-ai-real-world-database-solutions-you-can-use-today", "title": "SQL + AI: Real-World Database Solutions You Can Use Today", "summary": "A developer demonstrates how to integrate AI capabilities directly into PostgreSQL using the pgvector extension, enabling semantic search, natural language queries, and vector storage without a separate database. The approach combines SQL filters with cosine similarity searches in a single query, as shown with a product catalog example. All code is available on GitHub.", "body_md": "📦\n\nAll code examples in this article are available on GitHub:\n\n[github.com/andre-carbajal/sql-ai-database-solutions]\n\nDatabases and AI used to live in separate worlds. Your PostgreSQL instance handled structured queries, and your ML pipeline ran somewhere else entirely. That separation is rapidly disappearing.\n\nIn 2025, your SQL database can store embeddings, answer natural language questions, power semantic search, and serve as the memory layer for autonomous AI agents — all without adding a separate vector database to your stack.\n\nThis article walks through four real-world patterns with working code:\n\n```\npip install psycopg2-binary pgvector langchain langchain-openai openai sqlalchemy python-dotenv\n# Docker: run PostgreSQL with pgvector support\ndocker run --name pgvector-demo \\\n  -e POSTGRES_PASSWORD=secret \\\n  -p 5432:5432 \\\n  -d pgvector/pgvector:pg16\n```\n\nSet your environment variables:\n\n```\n# .env\nOPENAI_API_KEY=sk-...\nDATABASE_URL=postgresql://postgres:secret@localhost:5432/aidb\n```\n\n`pgvector`\n\nis a PostgreSQL extension that adds a native `vector`\n\ndata type, allowing you to store high-dimensional embeddings and run similarity searches with standard SQL.\n\nInstead of maintaining a separate vector database (Pinecone, Weaviate, Chroma), you keep your vectors *beside your relational data*. That means you can combine semantic search with SQL filters in a single query.\n\n```\n-- Enable the extension\nCREATE EXTENSION IF NOT EXISTS vector;\n\n-- Create a products table with an embedding column\nCREATE TABLE products (\n    id         SERIAL PRIMARY KEY,\n    name       TEXT NOT NULL,\n    description TEXT,\n    category   TEXT,\n    price      DECIMAL(10, 2),\n    embedding  VECTOR(1536)   -- OpenAI text-embedding-3-small dimensions\n);\n\n-- Create an HNSW index for fast approximate nearest-neighbor search\nCREATE INDEX ON products\nUSING hnsw (embedding vector_cosine_ops)\nWITH (m = 16, ef_construction = 64);\npython\nimport os\nimport psycopg2\nimport numpy as np\nfrom openai import OpenAI\nfrom dotenv import load_dotenv\n\nload_dotenv()\n\nclient = OpenAI(api_key=os.environ[\"OPENAI_API_KEY\"])\nconn = psycopg2.connect(os.environ[\"DATABASE_URL\"])\ncur = conn.cursor()\n\ndef get_embedding(text: str) -> list[float]:\n    response = client.embeddings.create(\n        model=\"text-embedding-3-small\",\n        input=text\n    )\n    return response.data[0].embedding\n\nproducts = [\n    (\"Wireless Noise-Cancelling Headphones\", \"Premium audio with 30hr battery\", \"electronics\", 299.99),\n    (\"Ergonomic Office Chair\",              \"Lumbar support, adjustable arms\",  \"furniture\",   449.00),\n    (\"Python Programming Book\",             \"Comprehensive guide for beginners\", \"books\",        39.99),\n    (\"Mechanical Keyboard\",                 \"Cherry MX switches, RGB backlit\",   \"electronics\", 129.00),\n    (\"Standing Desk\",                       \"Electric height-adjustable desk\",   \"furniture\",   599.00),\n]\n\nfor name, description, category, price in products:\n    embedding = get_embedding(f\"{name}: {description}\")\n    cur.execute(\n        \"\"\"\n        INSERT INTO products (name, description, category, price, embedding)\n        VALUES (%s, %s, %s, %s, %s)\n        \"\"\",\n        (name, description, category, price, embedding)\n    )\n\nconn.commit()\nprint(\"Products inserted with embeddings.\")\npython\ndef semantic_search(query: str, max_price: float = None, category: str = None, limit: int = 5):\n    query_embedding = get_embedding(query)\n\n    sql = \"\"\"\n        SELECT\n            name,\n            description,\n            category,\n            price,\n            1 - (embedding <=> %s::vector) AS similarity\n        FROM products\n        WHERE 1=1\n    \"\"\"\n    params = [query_embedding]\n\n    if max_price:\n        sql += \" AND price <= %s\"\n        params.append(max_price)\n\n    if category:\n        sql += \" AND category = %s\"\n        params.append(category)\n\n    sql += \" ORDER BY embedding <=> %s::vector LIMIT %s\"\n    params += [query_embedding, limit]\n\n    cur.execute(sql, params)\n    return cur.fetchall()\n\n# \"I want something for my home office under $500\"\nresults = semantic_search(\n    query=\"comfortable workspace setup for long work sessions\",\n    max_price=500.0\n)\n\nfor name, description, category, price, similarity in results:\n    print(f\"[{similarity:.3f}] {name} (${price}) — {description}\")\n```\n\n**Output:**\n\n```\n[0.891] Ergonomic Office Chair ($449.00) — Lumbar support, adjustable arms\n[0.832] Mechanical Keyboard ($129.00) — Cherry MX switches, RGB backlit\n[0.801] Standing Desk ($599.00) — Electric height-adjustable desk\n```\n\nThe\n\n`<=>`\n\noperator computescosine distance. pgvector also supports`<->`\n\n(L2/Euclidean) and`<#>`\n\n(inner product).\n\nRetrieval-Augmented Generation (RAG) lets you inject your own data into an LLM's context at query time. Instead of fine-tuning, you retrieve the most relevant chunks from your database and pass them as context.\n\n```\nUser Question\n     │\n     ▼\nEmbed the Question\n     │\n     ▼\nVector Search in PostgreSQL  ──▶  Top-K relevant chunks\n     │\n     ▼\nBuild LLM Prompt with context\n     │\n     ▼\nLLM generates answer grounded in your data\npython\nfrom langchain_openai import OpenAIEmbeddings, ChatOpenAI\nfrom langchain_community.vectorstores import PGVector\nfrom langchain.text_splitter import RecursiveCharacterTextSplitter\nfrom langchain.chains import RetrievalQA\nfrom langchain_community.document_loaders import TextLoader\n\n# 1. Load and chunk your documents\nloader = TextLoader(\"company_docs.txt\")\ndocuments = loader.load()\n\nsplitter = RecursiveCharacterTextSplitter(\n    chunk_size=500,\n    chunk_overlap=50\n)\nchunks = splitter.split_documents(documents)\n\n# 2. Store chunks + embeddings in PostgreSQL\nCONNECTION_STRING = os.environ[\"DATABASE_URL\"]\nCOLLECTION_NAME = \"company_knowledge_base\"\n\nvector_store = PGVector.from_documents(\n    documents=chunks,\n    embedding=OpenAIEmbeddings(model=\"text-embedding-3-small\"),\n    collection_name=COLLECTION_NAME,\n    connection_string=CONNECTION_STRING,\n)\n\n# 3. Build a retrieval-augmented QA chain\nllm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\nretriever = vector_store.as_retriever(\n    search_type=\"similarity\",\n    search_kwargs={\"k\": 4}\n)\n\nqa_chain = RetrievalQA.from_chain_type(\n    llm=llm,\n    chain_type=\"stuff\",\n    retriever=retriever,\n    return_source_documents=True\n)\n\n# 4. Ask questions\nresult = qa_chain.invoke({\"query\": \"What is our refund policy?\"})\nprint(result[\"result\"])\nprint(\"\\nSources:\")\nfor doc in result[\"source_documents\"]:\n    print(f\"  - {doc.metadata.get('source', 'unknown')}\")\n# Store documents with tenant metadata\nvector_store = PGVector.from_documents(\n    documents=chunks,\n    embedding=OpenAIEmbeddings(),\n    collection_name=\"docs\",\n    connection_string=CONNECTION_STRING,\n    # Each chunk carries metadata you can filter on\n)\n\n# Retrieve only documents for a specific tenant\nretriever = vector_store.as_retriever(\n    search_kwargs={\n        \"k\": 5,\n        \"filter\": {\"tenant_id\": \"acme-corp\"}\n    }\n)\n```\n\nNL2SQL (also called Text-to-SQL) lets users query your database in plain English. An LLM reads your schema and translates a natural language question into a valid SQL query.\n\n``` python\nfrom openai import OpenAI\n\nclient = OpenAI()\n\nSCHEMA = \"\"\"\nTables:\n  orders(id, customer_id, product_id, quantity, total_price, created_at, status)\n  customers(id, name, email, country, created_at)\n  products(id, name, category, price, stock)\n\"\"\"\n\ndef nl_to_sql(question: str) -> str:\n    prompt = f\"\"\"You are a SQL expert. Given the following database schema, write a PostgreSQL query to answer the user's question.\nReturn ONLY the SQL query, no explanation.\n\nSchema:\n{SCHEMA}\n\nQuestion: {question}\n\nSQL:\"\"\"\n\n    response = client.chat.completions.create(\n        model=\"gpt-4o-mini\",\n        messages=[{\"role\": \"user\", \"content\": prompt}],\n        temperature=0\n    )\n    return response.choices[0].message.content.strip()\n\n# Real-world examples\nquestions = [\n    \"What are the top 5 countries by total revenue this year?\",\n    \"Which products have never been ordered?\",\n    \"Show me customers who placed more than 3 orders in the last 30 days\",\n]\n\nfor q in questions:\n    print(f\"Q: {q}\")\n    print(f\"SQL: {nl_to_sql(q)}\")\n    print()\n```\n\n**Output:**\n\n```\n-- \"What are the top 5 countries by total revenue this year?\"\nSELECT c.country, SUM(o.total_price) AS total_revenue\nFROM orders o\nJOIN customers c ON o.customer_id = c.id\nWHERE EXTRACT(YEAR FROM o.created_at) = EXTRACT(YEAR FROM CURRENT_DATE)\nGROUP BY c.country\nORDER BY total_revenue DESC\nLIMIT 5;\n\n-- \"Which products have never been ordered?\"\nSELECT p.id, p.name, p.category\nFROM products p\nLEFT JOIN orders o ON p.id = o.product_id\nWHERE o.id IS NULL;\n```\n\nNever run LLM-generated SQL without validation. Here's a safer pattern:\n\n``` python\nimport sqlparse\nimport re\n\nALLOWED_STATEMENTS = {\"SELECT\"}\n\ndef is_safe_sql(sql: str) -> bool:\n    \"\"\"Reject anything that isn't a SELECT statement.\"\"\"\n    parsed = sqlparse.parse(sql)\n    if not parsed:\n        return False\n    statement_type = parsed[0].get_type()\n    return statement_type in ALLOWED_STATEMENTS\n\ndef execute_nl_query(question: str, conn) -> list[dict]:\n    sql = nl_to_sql(question)\n\n    # Strip markdown fences if LLM added them\n    sql = re.sub(r\"```\n\nsql|\n\n```\", \"\", sql).strip()\n\n    if not is_safe_sql(sql):\n        raise ValueError(f\"Unsafe SQL rejected: {sql}\")\n\n    cur = conn.cursor()\n    cur.execute(sql)\n    columns = [desc[0] for desc in cur.description]\n    rows = cur.fetchall()\n    return [dict(zip(columns, row)) for row in rows]\n```\n\nAdding examples dramatically improves query accuracy on complex schemas:\n\n```\nFEW_SHOT_EXAMPLES = \"\"\"\nExample 1:\nQuestion: How many orders were placed last month?\nSQL: SELECT COUNT(*) FROM orders WHERE created_at >= DATE_TRUNC('month', NOW() - INTERVAL '1 month') AND created_at < DATE_TRUNC('month', NOW());\n\nExample 2:\nQuestion: What is the average order value by product category?\nSQL: SELECT p.category, AVG(o.total_price) AS avg_order_value FROM orders o JOIN products p ON o.product_id = p.id GROUP BY p.category ORDER BY avg_order_value DESC;\n\"\"\"\n\ndef nl_to_sql_fewshot(question: str) -> str:\n    prompt = f\"\"\"You are a SQL expert for a PostgreSQL e-commerce database.\n\nSchema:\n{SCHEMA}\n\n{FEW_SHOT_EXAMPLES}\n\nQuestion: {question}\nSQL:\"\"\"\n    # ... same API call as before\n```\n\nThe most powerful pattern: an AI agent that can autonomously decide *which* queries to run, inspect the results, and iterate to answer complex multi-step questions.\n\n``` python\nfrom langchain.agents import AgentExecutor, create_openai_tools_agent\nfrom langchain_openai import ChatOpenAI\nfrom langchain.tools import tool\nfrom langchain import hub\nimport psycopg2\n\nconn = psycopg2.connect(os.environ[\"DATABASE_URL\"])\n\n@tool\ndef query_database(sql: str) -> str:\n    \"\"\"\n    Execute a read-only SQL SELECT query against the e-commerce database.\n    Use this to retrieve data needed to answer user questions.\n    Never use INSERT, UPDATE, DELETE, or DROP.\n    \"\"\"\n    if not is_safe_sql(sql):\n        return \"Error: Only SELECT queries are allowed.\"\n    try:\n        cur = conn.cursor()\n        cur.execute(sql)\n        columns = [desc[0] for desc in cur.description]\n        rows = cur.fetchmany(50)  # cap results\n        result = [dict(zip(columns, row)) for row in rows]\n        return str(result)\n    except Exception as e:\n        return f\"Query error: {e}\"\n\n@tool\ndef get_schema() -> str:\n    \"\"\"\n    Returns the database schema — table names, columns, and types.\n    Call this first to understand what data is available before writing queries.\n    \"\"\"\n    cur = conn.cursor()\n    cur.execute(\"\"\"\n        SELECT table_name, column_name, data_type\n        FROM information_schema.columns\n        WHERE table_schema = 'public'\n        ORDER BY table_name, ordinal_position;\n    \"\"\")\n    rows = cur.fetchall()\n    schema = {}\n    for table, column, dtype in rows:\n        schema.setdefault(table, []).append(f\"{column} ({dtype})\")\n    return \"\\n\".join(\n        f\"{table}: {', '.join(cols)}\"\n        for table, cols in schema.items()\n    )\n\n@tool\ndef semantic_product_search(query: str) -> str:\n    \"\"\"\n    Search for products using semantic/natural language similarity.\n    Use this when the user describes what they want rather than specifying exact product names.\n    \"\"\"\n    results = semantic_search(query, limit=5)\n    return str([{\"name\": r[0], \"description\": r[1], \"price\": r[3]} for r in results])\n\n# Assemble the agent\nllm = ChatOpenAI(model=\"gpt-4o\", temperature=0)\ntools = [get_schema, query_database, semantic_product_search]\n\nprompt = hub.pull(\"hwchase17/openai-tools-agent\")\n\nagent = create_openai_tools_agent(llm, tools, prompt)\nagent_executor = AgentExecutor(\n    agent=agent,\n    tools=tools,\n    verbose=True,\n    max_iterations=10\n)\n\n# Complex multi-step question\nresponse = agent_executor.invoke({\n    \"input\": \"\"\"\n    I'm looking for ergonomic office products. \n    Find the top 3 most relevant products, then check if we have customers \n    from Germany who bought office furniture in the past 6 months. \n    Give me a summary of both findings.\n    \"\"\"\n})\n\nprint(response[\"output\"])\n```\n\nThe agent will autonomously:\n\n`semantic_product_search(\"ergonomic office products\")`\n\n`get_schema()`\n\nto understand the tables\n\n```\n┌─────────────────────────────────────────────────────┐\n│                   PostgreSQL Database               │\n│                                                     │\n│  ┌─────────────┐  ┌──────────────┐  ┌───────────┐  │\n│  │  products   │  │  embeddings  │  │  orders   │  │\n│  │  customers  │  │  (pgvector)  │  │  ...      │  │\n│  └─────────────┘  └──────────────┘  └───────────┘  │\n└───────────────────────┬─────────────────────────────┘\n                        │\n           ┌────────────┼────────────┐\n           ▼            ▼            ▼\n     ┌──────────┐ ┌──────────┐ ┌──────────┐\n     │ Semantic │ │  NL2SQL  │ │  RAG     │\n     │  Search  │ │  Agent   │ │ Pipeline │\n     └──────────┘ └──────────┘ └──────────┘\n           │            │            │\n           └────────────┼────────────┘\n                        ▼\n                  ┌──────────┐\n                  │  LLM     │\n                  │ (GPT-4o) │\n                  └──────────┘\n                        │\n                        ▼\n                  User Response\n```\n\n**Index strategy for pgvector:**\n\n```\n-- HNSW: faster queries, slower inserts — best for production read-heavy workloads\nCREATE INDEX ON products USING hnsw (embedding vector_cosine_ops)\nWITH (m = 16, ef_construction = 64);\n\n-- IVFFlat: faster inserts, slightly less accurate — good for bulk loading\nCREATE INDEX ON products USING ivfflat (embedding vector_l2_ops)\nWITH (lists = 100);\n-- Rule of thumb: lists ≈ sqrt(number_of_rows)\n```\n\n**Batching embeddings:**\n\n```\n# Don't call the embeddings API one row at a time\ntexts = [f\"{p['name']}: {p['description']}\" for p in products]\n\nresponse = client.embeddings.create(\n    model=\"text-embedding-3-small\",\n    input=texts  # batch up to 2048 inputs at once\n)\nembeddings = [item.embedding for item in response.data]\n```\n\n**Caching repeated NL2SQL queries:**\n\n``` python\nimport hashlib\nimport json\n\nquery_cache: dict[str, str] = {}\n\ndef cached_nl_to_sql(question: str) -> str:\n    key = hashlib.md5(question.lower().strip().encode()).hexdigest()\n    if key not in query_cache:\n        query_cache[key] = nl_to_sql(question)\n    return query_cache[key]\n```\n\nBefore shipping any of these patterns to production:\n\n```\n-- Create a restricted role for your AI application\nCREATE ROLE ai_readonly;\nGRANT CONNECT ON DATABASE aidb TO ai_readonly;\nGRANT USAGE ON SCHEMA public TO ai_readonly;\nGRANT SELECT ON ALL TABLES IN SCHEMA public TO ai_readonly;\nALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO ai_readonly;\n```\n\nAll the code from this article — including Docker Compose setup, schema migrations, and ready-to-run examples — is in the companion repository:\n\nThe repo structure:\n\n```\nsql-ai-database-solutions/\n├── docker-compose.yml          # PostgreSQL + pgvector, ready to go\n├── schema/\n│   └── 001_init.sql            # Tables, pgvector extension, indexes\n├── examples/\n│   ├── 01_pgvector_search.py   # Semantic search\n│   ├── 02_rag_pipeline.py      # RAG with LangChain\n│   ├── 03_nl2sql.py            # Natural language to SQL\n│   └── 04_sql_agent.py         # Autonomous SQL agent\n├── .env.example\n└── README.md\n```\n\nThe patterns here are just the start. Some directions worth exploring:\n\nThe line between \"database\" and \"AI system\" is getting thinner every month. If you're already running PostgreSQL, you're closer to a production AI stack than you might think.\n\n*Have questions or want to share what you've built? Drop a comment below or open an issue on the repo!*", "url": "https://wpnews.pro/news/sql-ai-real-world-database-solutions-you-can-use-today", "canonical_source": "https://dev.to/andrecarbajal/sql-ai-real-world-database-solutions-you-can-use-today-5a6m", "published_at": "2026-06-27 20:49:39+00:00", "updated_at": "2026-06-27 21:33:43.340771+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "large-language-models", "developer-tools", "ai-infrastructure"], "entities": ["PostgreSQL", "pgvector", "OpenAI", "GitHub", "Andre Carbajal", "Pinecone", "Weaviate", "Chroma"], "alternates": {"html": "https://wpnews.pro/news/sql-ai-real-world-database-solutions-you-can-use-today", "markdown": "https://wpnews.pro/news/sql-ai-real-world-database-solutions-you-can-use-today.md", "text": "https://wpnews.pro/news/sql-ai-real-world-database-solutions-you-can-use-today.txt", "jsonld": "https://wpnews.pro/news/sql-ai-real-world-database-solutions-you-can-use-today.jsonld"}}