How to Build a customer support Agent Using LangChain in Python for investment banking

A customer support agent for investment banking handles client questions about onboarding, account access, trade status, statements, fees, corporate actions, and service requests without exposing sensitive data or inventing answers. It matters because the support layer sits next to regulated workflows, and every response needs to be accurate, auditable, permission-aware, and aligned with compliance rules.

Architecture

• •

  User-facing chat API

  • •Receives messages from relationship managers, operations staff, or approved clients.
  • •Authenticates the caller and attaches tenant, region, and entitlement context.
• •

  Policy and compliance layer

  • •Blocks responses that violate KYC/AML policy, confidentiality rules, or internal disclosure standards.
  • •Routes restricted questions to a human or a controlled workflow.
• •

  Retrieval layer

  • •Pulls answers from approved sources like product docs, SOPs, fee schedules, escalation playbooks, and internal knowledge bases.
  • •Uses VectorStoreRetriever so the agent answers from bank-approved content instead of guessing.
• •

  LLM orchestration

  • •Uses LangChain’s ChatPromptTemplate, create_retrieval_chain, and create_stuff_documents_chain.
  • •Keeps the model grounded in retrieved context and structured instructions.
• •

  Audit and observability

  • •Logs prompt inputs, retrieved documents, tool calls, final output, user identity, and policy decisions.
  • •Stores traces for review by compliance and model risk teams.
• •

  Human handoff path

  • •Escalates ambiguous cases like disputes, complaints, trading errors, or legal requests.
  • •Prevents the agent from becoming the final decision-maker on regulated issues.

Implementation

1. •

   Install LangChain and set up your document store

   Start with approved internal documents only. For investment banking support, that usually means client service manuals, product FAQs, fee schedules, cut-off times, SWIFT/payment procedures, and escalation policies.

   pip install langchain langchain-openai langchain-community chromadb tiktoken
   

   Load documents into a vector store. The example below uses Chroma with OpenAIEmbeddings, but the pattern is the same if you swap in an enterprise-hosted embedding model.

   from langchain_community.vectorstores import Chroma
   from langchain_openai import OpenAIEmbeddings
   from langchain_core.documents import Document
   
   docs = [
       Document(
           page_content="Client statements are available T+1 after market close. Requests older than 7 years require ops approval.",
           metadata={"source": "support_playbook", "region": "US"}
       ),
       Document(
           page_content="Trade status inquiries must be answered using OMS data. If status is pending review, escalate to operations.",
           metadata={"source": "trade_support", "region": "US"}
       ),
   ]
   
   embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
   vectorstore = Chroma.from_documents(docs, embedding=embeddings)
   retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
   

2. •

   Build a grounded retrieval chain

   Use a chat model with a strict system message. The prompt should force the assistant to answer only from retrieved context and refuse unsupported claims.

   from langchain_openai import ChatOpenAI
   from langchain_core.prompts import ChatPromptTemplate
   from langchain.chains.combine_documents import create_stuff_documents_chain
   from langchain.chains.retrieval import create_retrieval_chain
   
   llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
   
   prompt = ChatPromptTemplate.from_messages([
       ("system",
        "You are a customer support agent for investment banking. "
        "Answer only using the provided context. "
        "If the answer is not in context or involves legal/compliance advice, say you need to escalate to a human reviewer."),
       ("human",
        "Question: {input}\n\nContext:\n{context}")
   ])
   
   document_chain = create_stuff_documents_chain(llm=llm, prompt=prompt)
   rag_chain = create_retrieval_chain(retriever=retriever,
                                       combine_docs_chain=document_chain)
   

3. •

   Add a compliance gate before returning the answer

   This is where most teams get sloppy. You need deterministic checks for disallowed topics like trading advice, suitability recommendations, account-specific confidential data leakage, or requests that look like AML/KYC exceptions.

   DISALLOWED_PATTERNS = [
       "recommend stock",
       "investment advice",
       "circumvent kyc",
       "share client list",
       "bypass approval"
   ]
   
   def compliance_gate(user_text: str) -> bool:
       text = user_text.lower()
       return not any(pattern in text for pattern in DISALLOWED_PATTERNS)
   
   def answer_support_query(user_text: str) -> str:
       if not compliance_gate(user_text):
           return (
               "I can’t assist with that request here. "
               "This case needs human review under bank policy."
           )
   
       result = rag_chain.invoke({"input": user_text})
       return result["answer"]
   
   print(answer_support_query("When are client statements available?"))
   

4. •

   Wrap it in an API endpoint with audit logging

   In production you want request IDs, user IDs, region tags, retrieval traces, and final outputs recorded together. That gives compliance teams something they can review later without reconstructing events from scattered logs.

Production Considerations

• •

  Data residency

  • •Keep embeddings stores and logs in the same jurisdiction as the client data.
  • •If your bank has EU clients or APAC booking centers, do not send their content to an out-of-region SaaS endpoint without legal review.
• •

  Auditability

  • •Log every input/output pair with user identity, timestamp UTC), retrieved document IDs), model version), and escalation outcome).
  • •Preserve enough detail for model risk review without storing unnecessary PII.
• •

  Guardrails

  • •Add deterministic filters before LLM invocation for restricted topics.
  • •Use allowlisted source collections so the agent cannot retrieve random internal notes or unapproved documents.
• •

  Operational monitoring

  • •Track refusal rate), escalation rate), retrieval hit rate), hallucination reports), and latency.
  • •Sudden drops in retrieval quality often mean stale content or broken ingestion pipelines.

Common Pitfalls

1. •

   Letting the model answer from memory

   If you skip retrieval grounding, the agent will confidently invent policy details or service timelines. Fix this by forcing answers through create_retrieval_chain and refusing responses when no supporting document is found.

2. •

   Using broad internal search indexes

   Indexing everything sounds convenient until the agent starts surfacing confidential deal notes or restricted client data. Keep separate indexes for support content versus sensitive operational material, and enforce metadata filters by region and entitlement.

3. •

   Treating compliance as a prompt-only problem

   A system prompt saying “be compliant” is not enough for investment banking. Put hard checks in code for disallowed requests,, route edge cases to humans,, and log every decision for audit review.

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.