How to Integrate CrewAI for investment banking with FastAPI for startups

Combining CrewAI for investment banking with FastAPI gives you a clean way to expose agent workflows as HTTP services. For startups, that means you can turn research, deal screening, and memo generation into API endpoints your product can call without embedding agent logic everywhere.

The pattern is simple: CrewAI handles the multi-agent reasoning and task orchestration, while FastAPI wraps it in a stable service boundary. That gives you something production-friendly enough for internal tools, customer-facing workflows, and async job pipelines.

Prerequisites

• •Python 3.10+
• •fastapi
• •uvicorn
• •crewai
• •pydantic
• •An LLM provider configured for CrewAI, such as OpenAI or Azure OpenAI
• •API keys stored in environment variables
• •Basic familiarity with REST APIs and Python async patterns

Install the packages:

pip install fastapi uvicorn crewai pydantic

Set your environment variables:

export OPENAI_API_KEY="your-key"

Integration Steps

1. •Define your banking agents and tasks

Start by modeling the workflow inside CrewAI. For investment banking, a common split is research, analysis, and memo writing.

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Investment Banking Research Analyst",
    goal="Gather company and market context for startup deal screening",
    backstory="You analyze startups, markets, competitors, and financial signals.",
    verbose=True,
)

analyst = Agent(
    role="Financial Analyst",
    goal="Evaluate the startup's funding fit and risk profile",
    backstory="You assess growth signals, unit economics, and investor readiness.",
    verbose=True,
)

memo_writer = Agent(
    role="Deal Memo Writer",
    goal="Produce a concise investment banking memo for internal review",
    backstory="You write clear memos for partners and founders.",
    verbose=True,
)

research_task = Task(
    description="Research the startup's market, competitors, and funding context.",
    expected_output="A structured research summary with key risks and opportunities.",
    agent=researcher,
)

analysis_task = Task(
    description="Analyze the startup using the research summary and highlight investment risks.",
    expected_output="A financial analysis with recommendation notes.",
    agent=analyst,
)

memo_task = Task(
    description="Write an investment memo based on the research and analysis.",
    expected_output="A short deal memo suitable for partner review.",
    agent=memo_writer,
)

2. •Wrap the crew execution in a service function

Keep CrewAI execution isolated from your API layer. This makes retries, logging, and background execution easier later.

def run_investment_banking_workflow(startup_name: str) -> str:
    crew = Crew(
        agents=[researcher, analyst, memo_writer],
        tasks=[research_task, analysis_task, memo_task],
        process=Process.sequential,
        verbose=True,
    )

    result = crew.kickoff(inputs={"startup_name": startup_name})
    return str(result)

3. •Expose the workflow through FastAPI

Use FastAPI to create an endpoint that accepts input and returns the crew output. This is where your startup product talks to the agent system.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="Investment Banking AI Service")

class DealRequest(BaseModel):
    startup_name: str

class DealResponse(BaseModel):
    startup_name: str
    memo: str

@app.post("/analyze-deal", response_model=DealResponse)
def analyze_deal(payload: DealRequest):
    memo = run_investment_banking_workflow(payload.startup_name)
    return DealResponse(startup_name=payload.startup_name, memo=memo)

4. •Run it asynchronously if the workflow is slow

Investment banking workflows often take longer than a normal request timeout allows. If your crew does external research or long reasoning chains, push it to a background task or queue.

from fastapi import BackgroundTasks

def log_result(startup_name: str):
    result = run_investment_banking_workflow(startup_name)
    print(f"Completed analysis for {startup_name}: {result[:200]}")

@app.post("/analyze-deal-async")
def analyze_deal_async(payload: DealRequest, background_tasks: BackgroundTasks):
    background_tasks.add_task(log_result, payload.startup_name)
    return {"status": "queued", "startup_name": payload.startup_name}

5. •Add a clean server entrypoint

Keep deployment simple with Uvicorn. This lets you ship the service into Docker or any container platform without extra glue code.

# save as main.py
# then run: uvicorn main:app --reload --host 0.0.0.0 --port 8000

Testing the Integration

Send a request to verify FastAPI can trigger CrewAI end-to-end.

import requests

response = requests.post(
    "http://localhost:8000/analyze-deal",
    json={"startup_name": "Northstar AI"}
)

print(response.status_code)
print(response.json())

Expected output:

200
{
  "startup_name": "Northstar AI",
  "memo": "..."
}

If you want a quick local check without writing client code, hit the OpenAPI docs at:

• •http://localhost:8000/docs

That confirms FastAPI registered the route correctly and can execute the underlying CrewAI workflow.

Real-World Use Cases

• •

  Founder intake automation
  Build an endpoint that screens startup submissions and generates an initial investment memo for analysts.

• •

  Deal desk assistant
  Let bankers query a startup name or pitch deck ID and get structured research summaries before partner meetings.

• •

  Portfolio monitoring
  Trigger weekly agent runs that summarize portfolio company updates, fundraising signals, and competitor moves.

Production Notes

Keep the API layer thin. Put all agent logic in service functions so you can test it independently from HTTP concerns.

For startups building on this pattern:

• •Add request validation with stricter Pydantic models
• •Store outputs in Postgres or S3 for auditability
• •Add retries around LLM calls
• •Put long-running runs onto Celery or Redis Queue if latency matters

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.