How to Integrate Anthropic for healthcare with pgvector for startups

Anthropic for healthcare plus pgvector gives you a practical pattern for clinical AI: use Anthropic to interpret user intent, summarize medical context, and draft safe responses, then use pgvector to retrieve the most relevant policy docs, care protocols, or knowledge base entries from your own data.

For startups, this is the difference between a generic chatbot and an agent that can answer with context pulled from approved sources, while keeping retrieval inside your PostgreSQL stack.

Prerequisites

• •Python 3.10+
• •PostgreSQL 14+ with the pgvector extension installed
• •An Anthropic API key
• •A database user with permissions to create tables and extensions
• •A document set to index:
  • •care pathways
  • •internal medical FAQs
  • •triage scripts
  • •compliance-approved patient support content
• •Python packages:
  • •anthropic
  • •psycopg[binary]
  • •pgvector
  • •python-dotenv

Install them:

pip install anthropic psycopg[binary] pgvector python-dotenv

Integration Steps

1. •Set up PostgreSQL with pgvector and create your schema.

import psycopg

conn = psycopg.connect("postgresql://postgres:postgres@localhost:5432/healthai")
conn.execute("CREATE EXTENSION IF NOT EXISTS vector;")

conn.execute("""
CREATE TABLE IF NOT EXISTS clinical_docs (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT NOT NULL,
    embedding VECTOR(1536)
);
""")

conn.commit()
conn.close()

2. •Use Anthropic to generate embeddings-friendly text chunks and store them in pgvector.

Anthropic’s API is best used here for structured extraction and summarization. For retrieval embeddings, you typically pair it with your own embedding model; in startup systems, many teams use a dedicated embedding service and Anthropic for reasoning and generation. If you already have an embedding model, store vectors in pgvector like this:

import os
import psycopg
from pgvector.psycopg import register_vector

# Example embedding vector from your embedding pipeline.
# Replace this with real embeddings from your chosen embedding model.
sample_embedding = [0.012] * 1536

doc = {
    "title": "Asthma Triage Protocol",
    "content": "If the patient has wheezing, shortness of breath, or cyanosis...",
    "embedding": sample_embedding,
}

conn = psycopg.connect(os.environ["DATABASE_URL"])
register_vector(conn)

with conn.cursor() as cur:
    cur.execute(
        """
        INSERT INTO clinical_docs (title, content, embedding)
        VALUES (%s, %s, %s)
        """,
        (doc["title"], doc["content"], doc["embedding"])
    )

conn.commit()
conn.close()

3. •Call Anthropic to answer the user’s healthcare question using retrieved context from pgvector.

This is where the integration becomes useful. Retrieve the closest documents first, then pass them into Anthropic’s Messages API as grounded context.

import os
import anthropic
import psycopg
from pgvector.psycopg import register_vector

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

query_embedding = [0.013] * 1536  # Replace with real query embedding output

conn = psycopg.connect(os.environ["DATABASE_URL"])
register_vector(conn)

with conn.cursor() as cur:
    cur.execute(
        """
        SELECT title, content
        FROM clinical_docs
        ORDER BY embedding <-> %s
        LIMIT 3
        """,
        (query_embedding,)
    )
    rows = cur.fetchall()

context = "\n\n".join([f"Title: {title}\nContent: {content}" for title, content in rows])

response = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=400,
    messages=[
        {
            "role": "user",
            "content": f"""
You are a healthcare assistant for a startup support workflow.
Use only the provided context to answer.

Context:
{context}

Question:
What should I do if a patient reports wheezing and chest tightness?
"""
        }
    ]
)

print(response.content[0].text)

4. •Wrap retrieval + generation into a reusable agent function.

In production, don’t scatter database logic across handlers. Put it behind one function so your app can call it from chat, ticketing, or triage workflows.

import os
import anthropic
import psycopg
from pgvector.psycopg import register_vector

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

def answer_healthcare_query(question: str, query_embedding: list[float]) -> str:
    conn = psycopg.connect(os.environ["DATABASE_URL"])
    register_vector(conn)

    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT title, content
            FROM clinical_docs
            ORDER BY embedding <-> %s
            LIMIT 5
            """,
            (query_embedding,)
        )
        docs = cur.fetchall()

    conn.close()

    context = "\n\n".join(
        [f"[{i+1}] {title}\n{content}" for i, (title, content) in enumerate(docs)]
    )

    result = client.messages.create(
        model="claude-3-5-sonnet-latest",
        max_tokens=500,
        temperature=0,
        messages=[
            {
                "role": "user",
                "content": f"""
Answer the question using only these sources:

{context}

Question: {question}

If the sources are insufficient, say so clearly.
"""
            }
        ]
    )

    return result.content[0].text

5. •Add metadata filtering for startup-grade routing.

Most healthcare workflows need more than similarity search. You’ll want to filter by source type, jurisdiction, or document version before passing context to Anthropic.

with conn.cursor() as cur:
    cur.execute(
        """
        SELECT title, content
        FROM clinical_docs
        WHERE title ILIKE %s
        ORDER BY embedding <-> %s
        LIMIT 3
        """,
        ("%triage%", query_embedding)
    )

Testing the Integration

Run a simple end-to-end test that inserts one document, retrieves it by vector similarity, and asks Anthropic to answer from that context.

test_question = "What symptoms require urgent escalation?"
test_embedding = [0.02] * 1536

answer = answer_healthcare_query(test_question, test_embedding)
print(answer)

Expected output:

The retrieved protocol indicates urgent escalation is required for severe shortness of breath,
cyanosis, inability to speak in full sentences, or worsening chest tightness.
If these symptoms are present, direct the patient to emergency care immediately.

Real-World Use Cases

• •Clinical support agent
  • •Ground patient-facing responses in approved care documentation stored in PostgreSQL.
• •Prior authorization helper
  • •Retrieve policy excerpts with pgvector and have Anthropic draft structured summaries for reviewers.
• •Care navigation assistant
  • •Route users to the right next step based on symptoms, plan rules, and internal triage playbooks.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.