AWS Builder Center

Builder Center

Building RivalFree: Deploying an Autonomous Multi-Agent AI System on AWS EC2 with WebSockets and SerpApi Grounding

Building RivalFree: Deploying an Autonomous Multi-Agent AI System on AWS EC2 with WebSockets and SerpApi Grounding

A complete technical deep-dive on containerizing a real-time multi-agent SaaS platform on AWS EC2, featuring Nginx reverse proxying, Socket.IO streaming, and SerpApi live web grounding.

Sumeet Umbalkar

Software Engineer | Backend & System
Title
Building RivalFree: Deploying an Autonomous Multi-Agent AI System on AWS EC2 with WebSockets and SerpApi Grounding


Description

A complete technical deep-dive on containerizing a real-time multi-agent SaaS platform on AWS EC2, featuring Nginx reverse proxying, Socket.IO streaming, and SerpApi live web grounding.

Market research for new SaaS products often takes days of manual browser digging—parsing competitor pricing, searching forums, and spotting feature gaps. RivalFree automates this entire pipeline into a 15-second multi-agent workflow.
To achieve fast, low-latency streaming and reliable web research without LLM hallucinations, we deployed our containerized application directly onto AWS infrastructure. Here is an architectural deep-dive into how RivalFree was built and hosted on AWS.


High-Level Architecture Overview

RivalFree operates on a 3-tier cloud setup:
  1. Client Tier: React SPA rendering an interactive agent progress terminal and real-time chat drawers.
  1. Compute & Orchestration Tier: AWS EC2 instance running Docker containers behind Nginx. Node.js orchestrates multi-agent tasks using LangChain, Google Gemini models, and SerpApi.
  1. Data & State Tier: MongoDB Atlas for persisting projects, market analysis schemas, and persistent chat sessions.


Step 1: Solving the Live Intelligence Challenge (SerpApi + Multi-Agent Pipeline)

LLMs suffer from static knowledge cutoffs and hallucination risks when asked about current market competitors or pricing. We resolved this by integrating SerpApi directly into our agent pipeline:
  • Stage 1 (Query Planning): Translates raw user project inputs into targeted search operators.
  • Stage 2 (Live SERP Scanning): Uses SerpApi to scrape live search index data, competitor landing pages, and customer forum feedback.
  • Stage 3 (Parallel Synthesis): Runs parallel LLM chains to construct market positioning maps and isolate missing feature voids simultaneously.


Step 2: Containerizing the Backend with Docker

To ensure environment consistency between local development and AWS production, we built a multi-stage  Dockerfile :
dockerfile
FROM node:20-alpine AS builder

WORKDIR /app

COPY package*.json ./

RUN npm ci

COPY . .



FROM node:20-alpine AS runner

WORKDIR /app

ENV NODE_ENV=production

COPY package*.json ./

RUN npm ci --only=production

COPY --from=builder /app ./



EXPOSE 5000

CMD ["node", "src/index.js"]


We orchestrate local runtime configuration using  docker-compose.yml :
YAML
version: '3.8'

services:

  api:

    build: .

    container_name: rivalfree-backend

    restart: always

    ports:

      - "5000:5000"

    env_file:

      - .env

    environment:

      - NODE_ENV=production




Step 3: Production Deployment on AWS EC2 & Nginx Reverse Proxy

We opted for an AWS EC2 Ubuntu 24.04 LTS instance to maintain complete control over TCP connections and WebSocket streaming.

1. Network Configuration

In the AWS Security Group, we exposed:
  • Port 22: SSH Access
  • Port 80: Standard HTTP
  • Port 443: Secure HTTPS

2. Nginx Reverse Proxy & WebSocket Configuration

Standard HTTP proxies break WebSocket connections. We configured  /etc/nginx/sites-available/default  to upgrade headers explicitly for Socket.IO:
nginx
server {

    listen 80;

    server_name api.yourdomain.com;



    location / {

        proxy_pass http://localhost:5000;

        proxy_http_version 1.1;



        # WebSockets Support for Socket.IO

        proxy_set_header Upgrade $http_upgrade;

        proxy_set_header Connection "upgrade";



        proxy_set_header Host $host;

        proxy_set_header X-Real-IP $remote_addr;

        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

        proxy_set_header X-Forwarded-Proto $scheme;

    }

}



3. Automated SSL via Certbot

We secured the endpoint with free Let's Encrypt certificates directly on the instance:
Bash
sudo certbot --nginx -d api.yourdomain.com




Step 4: UI/UX & Fallback Handling

To keep user experience seamless during long-running agent tasks, our React frontend renders dynamic status indicators and contextual execution logs. We implemented a 10-second inactivity fallback timer on the final saving step to guarantee smooth state resolution even during minor network hiccups.


Here is live link

Live :  https://rivalfree.sumeet.app/ 
GitHub :  https://github.com/sumeet57/rivalfree/ 


Key Takeaways & Lessons Learned

  1. Grounding Matters: Pairing open/closed model agents with live SERP search results from SerpApi completely removes LLM data hallucinations.
  1. AWS EC2 + Nginx Flexibility: Hosting Docker containers on EC2 behind Nginx gives full operational transparency over WebSocket streams at negligible cost.
  1. Containerization Simplifies Cloud Deployment: Using multi-stage Docker builds allowed us to go from local code to live AWS infrastructure in under 20 minutes.
# ai# docker# amazon-ec2# agents# challenge
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article