How to Integrate OpenAI for pension funds with Pinecone for production AI

If you’re building AI for pension funds, you need two things working together: a model that can reason over policy, member queries, and operational documents, and a retrieval layer that can pull the right context fast. OpenAI gives you the generation and reasoning layer; Pinecone gives you persistent vector search over fund documents, investment policy statements, FAQs, call transcripts, and compliance notes.

That combination is what turns a generic chatbot into a production-grade agent that can answer pension-specific questions with grounded context instead of guessing.

Prerequisites

Before wiring this up, make sure you have:

• •Python 3.10+
• •An OpenAI API key
• •A Pinecone API key
• •A Pinecone index created with the right embedding dimension
• •pip installed
• •These packages:
  • •openai
  • •pinecone
  • •tiktoken or your preferred chunking library
  • •python-dotenv for local development

Install the SDKs:

pip install openai pinecone python-dotenv

Set environment variables:

export OPENAI_API_KEY="your-openai-key"
export PINECONE_API_KEY="your-pinecone-key"
export PINECONE_INDEX_NAME="pension-fund-docs"

Integration Steps

1. •Create embeddings with OpenAI and prepare pension documents

You want to chunk source material first: fund rules, retirement benefit guides, contribution schedules, trustee meeting notes, and compliance docs. Then convert each chunk into embeddings using OpenAI.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

docs = [
    {
        "id": "doc-001",
        "text": "The pension fund allows voluntary additional contributions up to 15% of monthly salary."
    },
    {
        "id": "doc-002",
        "text": "Members may request benefit statements quarterly through the member portal."
    }
]

def embed_text(text: str):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

embedded_docs = []
for doc in docs:
    embedded_docs.append({
        "id": doc["id"],
        "values": embed_text(doc["text"]),
        "metadata": {"text": doc["text"]}
    })

print(f"Embedded {len(embedded_docs)} documents")

2. •Create or connect to a Pinecone index

Your Pinecone index must match the embedding dimension from the model you use. For text-embedding-3-small, create an index with the correct dimension for your setup and use cosine similarity.

import os
from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
index_name = os.environ["PINECONE_INDEX_NAME"]

existing_indexes = [idx["name"] for idx in pc.list_indexes()]

if index_name not in existing_indexes:
    pc.create_index(
        name=index_name,
        dimension=1536,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="us-east-1")
    )

index = pc.Index(index_name)
print(f"Connected to Pinecone index: {index_name}")

3. •Upsert embedded pension content into Pinecone

Store both vectors and metadata. In production, keep metadata rich enough to support filtering by document type, jurisdiction, plan name, or effective date.

vectors = []
for item in embedded_docs:
    vectors.append((
        item["id"],
        item["values"],
        item["metadata"]
    ))

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

4. •Retrieve relevant context from Pinecone for a user query

When a member asks a question, embed the query with OpenAI, then search Pinecone for top matches. This is where retrieval grounding happens.

query = "Can I make additional voluntary contributions?"

query_embedding = client.embeddings.create(
    model="text-embedding-3-small",
    input=query
).data[0].embedding

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

for match in results.matches:
    print(match.id)
    print(match.score)
    print(match.metadata["text"])

5. •Use OpenAI to generate a grounded answer from retrieved context

Pass the retrieved snippets into the model as context. Keep the prompt strict so the assistant only answers from source material.

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

context = "\n".join(context_blocks)

response = client.responses.create(
    model="gpt-4o-mini",
    input=[
        {
            "role": "system",
            "content": (
                "You answer questions about pension funds using only the provided context. "
                "If the answer is not in the context, say you don't have enough information."
            )
        },
        {
            "role": "user",
            "content": f"Context:\n{context}\n\nQuestion:\n{query}"
        }
    ]
)

print(response.output_text)

Testing the Integration

Use one known question from your pension documentation and verify that retrieval returns relevant chunks before generation runs.

test_query = "How much can members contribute voluntarily?"

test_embedding = client.embeddings.create(
    model="text-embedding-3-small",
    input=test_query
).data[0].embedding

test_results = index.query(
    vector=test_embedding,
    top_k=1,
    include_metadata=True
)

assert len(test_results.matches) > 0
assert "voluntary additional contributions" in test_results.matches[0].metadata["text"].lower()

print("Retrieval OK")
print("Top match:", test_results.matches[0].metadata["text"])

answer = client.responses.create(
    model="gpt-4o-mini",
    input=f"Use this context only: {test_results.matches[0].metadata['text']}\n\nQuestion: {test_query}"
)

print("Generated answer:", answer.output_text)

Expected output:

Retrieval OK
Top match: The pension fund allows voluntary additional contributions up to 15% of monthly salary.
Generated answer: Members may make voluntary additional contributions up to 15% of monthly salary.

Real-World Use Cases

• •

  Member self-service assistant

  • •Answer contribution, withdrawal, retirement age, and benefit statement questions using fund-approved documents.
• •

  Trustee and operations copilot

  • •Search board minutes, policy updates, and regulatory notices to draft summaries or locate decision history quickly.
• •

  Compliance-aware document QA

  • •Let internal teams query policy manuals and investment guidelines while keeping answers grounded in indexed source material.

The pattern here is simple: OpenAI handles language understanding and generation; Pinecone handles durable retrieval over pension knowledge. Put them together with strict prompting and good document hygiene, and you get an agent that’s useful in production instead of just impressive in a demo.

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.