How to Integrate OpenAI for healthcare with Pinecone for startups

Combining OpenAI for healthcare with Pinecone gives you a clean pattern for building clinical AI agents that can answer from trusted internal knowledge instead of hallucinating. For startups, that means patient support assistants, triage copilots, and care navigation tools that can retrieve the right policy, guideline, or protocol before generating a response.

Prerequisites

• •Python 3.10+
• •An OpenAI API key with access to the healthcare-capable model you plan to use
• •A Pinecone account and API key
• •A Pinecone index created with the correct dimension for your embedding model
• •pip installed
• •Basic familiarity with async Python if you want to use the newer OpenAI SDK patterns
• •A document source for healthcare content:
  • •clinical FAQs
  • •SOPs
  • •care pathways
  • •insurance coverage rules
  • •patient-facing knowledge base articles

Install the SDKs:

pip install openai pinecone-client python-dotenv

Integration Steps

1. •Set up your clients and environment variables.

Use separate keys for each service and keep them out of source control.

import os
from dotenv import load_dotenv
from openai import OpenAI
from pinecone import Pinecone

load_dotenv()

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
PINECONE_INDEX_NAME = os.getenv("PINECONE_INDEX_NAME")

client = OpenAI(api_key=OPENAI_API_KEY)
pc = Pinecone(api_key=PINECONE_API_KEY)
index = pc.Index(PINECONE_INDEX_NAME)

2. •Generate embeddings for your healthcare documents using OpenAI.

For retrieval, embed chunks of policy or clinical content before upserting them into Pinecone.

documents = [
    {
        "id": "doc-001",
        "text": "For non-emergency symptoms, advise patients to contact their primary care provider within 24 hours.",
        "metadata": {"source": "triage_policy", "category": "care_guidance"}
    },
    {
        "id": "doc-002",
        "text": "Patients with chest pain, shortness of breath, or loss of consciousness should seek emergency care immediately.",
        "metadata": {"source": "red_flag_policy", "category": "emergency"}
    }
]

texts = [d["text"] for d in documents]

embedding_response = client.embeddings.create(
    model="text-embedding-3-small",
    input=texts
)

vectors = []
for doc, item in zip(documents, embedding_response.data):
    vectors.append({
        "id": doc["id"],
        "values": item.embedding,
        "metadata": {
            **doc["metadata"],
            "text": doc["text"]
        }
    })

3. •Upsert vectors into Pinecone.

Store the embeddings plus metadata so your agent can retrieve both the text and its provenance.

upsert_result = index.upsert(vectors=vectors)
print(upsert_result)

4. •Query Pinecone first, then send retrieved context to OpenAI for generation.

This is the standard RAG flow: retrieve relevant medical content from Pinecone, then have OpenAI draft the answer grounded in that context.

def retrieve_context(query: str, top_k: int = 3) -> str:
    query_embedding = client.embeddings.create(
        model="text-embedding-3-small",
        input=query
    ).data[0].embedding

    results = index.query(
        vector=query_embedding,
        top_k=top_k,
        include_metadata=True
    )

    contexts = []
    for match in results.matches:
        if match.metadata and "text" in match.metadata:
            contexts.append(match.metadata["text"])

    return "\n\n".join(contexts)

user_query = "What should I tell a patient who has chest pain?"
context = retrieve_context(user_query)

5. •Generate a grounded response with OpenAI.

Use the retrieved context as system or developer context so the model stays tied to approved healthcare content.

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": (
                "You are a healthcare support assistant. "
                "Answer only using the provided context. "
                "If the context is insufficient, say you don't have enough information."
            )
        },
        {
            "role": "user",
            "content": f"Context:\n{context}\n\nQuestion:\n{user_query}"
        }
    ],
    temperature=0.2
)

print(response.choices[0].message.content)

Testing the Integration

Run a simple end-to-end test: embed docs, store them, retrieve by query, and generate an answer.

test_query = "When should someone seek emergency care for chest pain?"
test_context = retrieve_context(test_query)

test_response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "Answer only from context."
        },
        {
            "role": "user",
            "content": f"Context:\n{test_context}\n\nQuestion:\n{test_query}"
        }
    ],
    temperature=0.0
)

print("Retrieved context:")
print(test_context)
print("\nModel output:")
print(test_response.choices[0].message.content)

Expected output:

Retrieved context:
Patients with chest pain, shortness of breath, or loss of consciousness should seek emergency care immediately.

Model output:
Patients with chest pain should seek emergency care immediately.

Real-World Use Cases

• •

  Patient support agent

  • •Answer common questions from approved care guidance and escalation policies.
  • •Route high-risk symptoms to emergency instructions instead of generic advice.
• •

  Clinical operations copilot

  • •Retrieve SOPs, prior cases, and internal protocols for staff-facing workflows.
  • •Draft consistent responses for scheduling, referrals, and follow-up instructions.
• •

  Insurance or benefits assistant

  • •Search coverage rules and policy documents.
  • •Explain eligibility or next steps using grounded internal knowledge rather than free-form generation.

The production pattern is straightforward: chunk trusted healthcare content, embed it with OpenAI, store it in Pinecone, then retrieve relevant passages before asking OpenAI to generate an answer. That gives startups a controllable agent stack with better accuracy than prompt-only systems and a clear path to auditability through metadata and source text.

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.