How to Integrate OpenAI for fintech with Pinecone for multi-agent systems

Combining OpenAI for fintech with Pinecone gives you a clean pattern for multi-agent systems that need both reasoning and retrieval. In practice, this lets one agent interpret financial intent, another agent pull policy or market context from Pinecone, and a coordinator agent turn both into an auditable answer.

That matters in fintech because the model should not guess. You want structured responses grounded in your own product docs, compliance rules, customer history, or investment knowledge base.

Prerequisites

• •Python 3.10+
• •An OpenAI API key with access to the models 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 run multiple agents concurrently
• •Environment variables set:
  • •OPENAI_API_KEY
  • •PINECONE_API_KEY
  • •PINECONE_INDEX_NAME

Install the SDKs:

pip install openai pinecone python-dotenv

Integration Steps

1. •Set up clients for OpenAI and Pinecone.

Use the official SDKs and keep credentials out of code. For a production service, load keys from environment variables or a secret manager.

import os
from openai import OpenAI
from pinecone import Pinecone

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

index_name = os.environ["PINECONE_INDEX_NAME"]
index = pc.Index(index_name)

2. •Create embeddings with OpenAI and store them in Pinecone.

This is the core retrieval path. You embed your fintech content once, then query it later from any agent.

from openai import OpenAI
from pinecone import Pinecone

client = OpenAI()
pc = Pinecone()

index = pc.Index("fintech-agent-memory")

docs = [
    {
        "id": "policy_001",
        "text": "KYC checks are required before enabling transfers above $10,000.",
        "metadata": {"type": "policy", "domain": "compliance"}
    },
    {
        "id": "product_001",
        "text": "Instant transfers are available only for verified accounts in supported regions.",
        "metadata": {"type": "product", "domain": "payments"}
    }
]

embeddings = client.embeddings.create(
    model="text-embedding-3-small",
    input=[d["text"] for d in docs]
)

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

index.upsert(vectors=vectors)

3. •Query Pinecone from an agent using the user’s request as retrieval input.

In a multi-agent system, this is usually the “retriever” or “context agent.” It pulls only the relevant snippets before handing them to the reasoning agent.

query = "Can I enable transfers above $10k for a new customer?"
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
)

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

print(matches)

4. •Send retrieved context to OpenAI for grounded generation.

This is where OpenAI does the actual reasoning. Keep the prompt narrow and force the model to answer only from retrieved context when dealing with regulated workflows.

context = "\n".join(matches)

response = client.responses.create(
    model="gpt-4o-mini",
    input=[
        {
            "role": "system",
            "content": (
                "You are a fintech assistant. Answer only using the provided context. "
                "If the context is insufficient, say so."
            )
        },
        {
            "role": "user",
            "content": f"Context:\n{context}\n\nQuestion: {query}"
        }
    ]
)

print(response.output_text)

5. •Wire multiple agents together with a simple orchestration layer.

A practical multi-agent setup splits responsibilities:

• •Agent A: intent classification
• •Agent B: Pinecone retrieval
• •Agent C: compliance-aware response generation

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

    res = index.query(vector=q_emb, top_k=3, include_metadata=True)
    return "\n".join([m["metadata"]["text"] for m in res["matches"]])

def answer_fintech_question(question: str) -> str:
    ctx = retrieve_context(question)

    resp = client.responses.create(
        model="gpt-4o-mini",
        input=[
            {"role": "system", "content": "Answer only from context. Be concise and factual."},
            {"role": "user", "content": f"Context:\n{ctx}\n\nQuestion: {question}"}
        ]
    )
    return resp.output_text

print(answer_fintech_question("What are the requirements for transfers above $10k?"))

Testing the Integration

Run a smoke test that checks embedding creation, vector search, and response generation end to end.

test_question = "What checks are needed before approving high-value transfers?"
answer = answer_fintech_question(test_question)

print("QUESTION:", test_question)
print("ANSWER:", answer)

Expected output should look like this:

QUESTION: What checks are needed before approving high-value transfers?
ANSWER: KYC checks are required before enabling transfers above $10,000.

If you get empty matches or vague answers:

• •confirm your Pinecone index dimension matches text-embedding-3-small
• •verify documents were actually upserted
• •check that metadata includes the source text
• •make sure your prompt tells the model to stay within retrieved context

Real-World Use Cases

• •

  Compliance copilot

  • •One agent retrieves policy snippets from Pinecone.
  • •Another agent uses OpenAI to explain whether a transaction violates policy and why.
• •

  Customer support triage

  • •Route banking questions through an intent agent.
  • •Pull product docs and account rules from Pinecone.
  • •Generate precise responses without exposing unsupported claims.
• •

  Advisor workflow assistant

  • •Store research notes, portfolio guidelines, and client preferences in Pinecone.
  • •Use OpenAI to summarize suitable actions for relationship managers across multiple agents.

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.