Conference Copilot AI

Framing the Problem

Tech conferences, hackathons, and industry events offer tremendous opportunities for learning, networking, and career growth. However, attendees often struggle to identify which sessions are most relevant to their interests, which people they should connect with, and which sponsor booths or opportunities are worth their limited time.

As conferences grow larger, attendees face information overload. They spend significant time navigating schedules, comparing sessions, and deciding where to go next, often missing valuable talks, networking opportunities, or resources that align with their goals. Many participants leave events feeling that they could have gained more value if they had better guidance.

This problem affects:

• Students looking for internships, mentors, and learning opportunities.

• Developers and professionals seeking relevant technical sessions and industry connections.

• Job seekers trying to meet recruiters and hiring managers.

• Founders and entrepreneurs looking for investors, partners, and customers.

• Conference organizers, whose attendees may not fully engage with all available content and opportunities.

Our goal is to solve this by providing an AI-powered Conference Copilot that analyzes an attendee's profile, interests, and goals, then recommends the most relevant talks, people, and opportunities while generating a personalized conference experience.

Idea Explanation

Conference Copilot AI is an AI-powered assistant designed to help attendees get the maximum value from conferences, hackathons, and professional events.

The platform starts by building a personalized attendee profile using information such as the user's interests, skills, career goals, GitHub profile, LinkedIn profile, or manually entered preferences. It then analyzes conference data, including schedules, speakers, sessions, sponsors, and networking opportunities.

Using AI, the platform recommends:

• Which talks and workshops to attend based on the attendee's interests and goals.

• Which people to connect with such as recruiters, founders, speakers, mentors, or professionals with similar interests.

• Which sponsor booths and opportunities to explore that are relevant to the attendee's career path.

• A personalized conference schedule that combines sessions, networking opportunities, and important event activities into a single optimized plan.

Instead of forcing attendees to manually browse hundreds of sessions and opportunities, Conference Copilot acts as a personal guide that helps them make informed decisions throughout the event.

By delivering tailored recommendations and an optimized agenda, the platform reduces information overload, improves networking outcomes, and helps attendees discover the opportunities most relevant to their personal and professional goals. This transforms large, overwhelming conferences into focused, productive, and meaningful experiences.

Implementation

The system is built on a client-server architecture powered by AI integrations and database persistence:

• Frontend (React/Vite/TS): Manages the user interface, routing, styling, state machine, and dashboards (e.g. Profile Onboarding, customized agendas, networking views, etc.).

• Backend (FastAPI): Exposes a set of REST API endpoints for user profiles, agenda parsing, and recommended networking/sponsors/talks. It acts as the orchestrator between the database layer and the AI API services.

• AI Service (ai.py): Performs NLP, parses agendas from raw HTML strings, and uses LLMs (Groq Llama 3 / Google Gemini) to rank/align networking matches, schedules, and booth itineraries with the attendee's interests.

2. Frontend-to-Backend Requests

Yes, the React frontend makes asynchronous HTTP REST requests to the FastAPI backend.

In App.tsx, requests are made using the standard JavaScript fetch API to communicate with backend routes. Examples include:

• /api/profile: Exposes GET to fetch profiles and POST to update the user's details, interests, and goals.

• /api/recommendations/talks: Fetches dynamically matched sessions based on the attendee's profile.

• /api/recommendations/networking: Retrieves customized person-to-person networking suggestions.

• /api/recommendations/booths: Retrieves sponsor booth suggestions aligned with attendee goals.

• /api/schedule/optimized: Persists and pulls customized scheduler timelines.

3. Where the Database Fits In

The database is managed by the DatabaseManager class in database.py.

• Primary DB (Supabase/PostgreSQL): When the backend starts up, it reads credentials (SUPABASE_URL and SUPABASE_KEY) from environment variables. If present, it connects using the Supabase client to store and retrieve data from relational tables (profiles, agendas, sessions, sponsors).

• Fallback DB (Local In-Memory Cache): If Supabase environment variables are missing or a connection error occurs, the app seamlessly falls back to writing/reading from an in-memory Python dictionary structure (_local_db). This design ensures that the MVP continues running smoothly offline or without production cloud credentials.

Challenges

1. External API Reliability & Missing LLM Credentials

• The Struggle: Because this app relies heavily on Large Language Models to parse raw event schedules and generate custom recommendations, it is highly vulnerable to network failures, rate-limiting, and missing API keys (especially when other developers clone and run the repo for the first time).

• How We Overcame It: In ai.py, we implemented a three-tier AI service pipeline:

  1. Primary LLM: Attempts high-speed inference via the Groq API (Llama-3.3-70b-versatile).

  2. Secondary Fallback: If Groq fails or is not configured, it catches the exception and routes the prompt to the Google Gemini API (Gemini 2.5 Flash).

  3. Local Offline Engine: If no API keys are present in the .env file, the service falls back to a local keyword-matching and token-scoring heuristic engine to categorize sessions and make networking matches locally without throwing errors.

2. Relational Database and Backend Connectivity Constraints

• The Struggle: Saving agenda information, session schedules, and user onboarding profiles requires database access. If the developer doesn't have a Supabase project configured or is working offline, backend database operations would normally crash the application.

• How We Overcame It:

  • Database Cache Fallback: In database.py, we built an in-memory dictionary storage (_local_db). All database helper functions check if the Supabase client is initialized. If not, they seamlessly read/write to the in-memory cache.

  • Client Simulation Mode: In App.tsx, if the React client cannot establish a connection to the FastAPI server, it automatically triggers a Client Simulation Mode. This lets reviewers preview the full range of onboarding, networking, and scheduling features entirely on the client side using robust mock datasets, ensuring zero downtime.

3. High Token Overhead & Noise in Web Scraping

• The Struggle: When scraping event schedules directly from user-submitted URLs, raw HTML code contains massive amounts of non-semantic overhead (such as CSS styles, inline scripts, SVG graphics, navigation headers, and footer tracking). Sending this directly to an LLM wastes API costs, increases latency, and can overflow the context window.

• How We Overcame It: In main.py, we implemented an aggressive regex-based pre-processing pipeline. It strips out <script>, <style>, <head>, <nav>, <footer>, and <svg> tags, collapses extra spaces, and truncates the payload to a maximum token-safe size of 25,000 characters before handing it to the AI. This results in significantly faster, more accurate parser results.

4. Dynamic Syncing of Multi-panel Recommendations

• The Struggle: Linking 20 unique events required that selecting a new event dynamically changes recommendations in the AI Networking, AI Booth Guide, and Personalized Schedule views concurrently, ensuring that no suggestions are repeated or mismatched.

• How We Overcame It: We structured event data to index all recommendations under explicit event IDs in both event_data.py (backend) and event_data.ts (frontend). When a new event is selected, the application updates a central state context, triggering batch calls to fetch the corresponding dataset for all views simultaneously, preventing cross-talk or stale information.

Accomplishments

What We Accomplished

1. Dynamic Multi-Event Synchronization:

   • Populated the application with 20 unique technical events and conferences, complete with realistic metadata (venues, dates, titles, descriptions).

   • Linked these events to the backend, enabling selecting any event in the UI to instantly refresh and customize the AI Networking, AI Booth Guide, and Personalized Schedule dashboards without overlapping or repetitive data.

2. Robust Multi-Tiered AI Architecture:

   • Built the AIService in ai.py to support Groq (Llama-3), Gemini (Gemini 2.5 Flash), and a regex/keyword-matching heuristic engine fallback.

3. Resilient Database Layer:

   • Configured a hybrid database layer using the DatabaseManager in database.py that utilizes Supabase (PostgreSQL) when online and falls back to a clean in-memory server state (_local_db) when offline.

4. Adaptive UI Experience:

   • Designed a premium UI featuring Kendo UI Scheduler, Tailwind CSS glassmorphism, custom theme layouts, and an Automatic Simulation Fallback Mode that keeps the frontend interactive even if the backend server is stopped.

What We Learned

• Designing for Resiliency (Offline-First AI): We learned that relying strictly on live cloud LLM APIs makes software fragile. Building local fallback heuristic logic ensures the software remains functional and presentable regardless of API keys, rate limits, or network conditions.

• Token footprint optimization is critical: Directly feeding raw scraped HTML into LLMs is costly and slow. Stripping noise (such as script and style blocks) via regex pre-processing is essential for fast, budget-friendly structured JSON generations.

• Synchronized Application State Management: Coordinating updates across multiple independent views (Scheduler, Networking, Sponsors) taught us how to design cohesive backend payloads that package all matching event assets together, reducing API request counts and preventing UI layout lag.

Next Steps

1. Multi-User Authentication & Profiles

• Current State: The database layer (database.py) is simplified for a single user, updating or retrieving a single profile row.

• Improvement: Integrate Supabase Auth (OAuth with GitHub/LinkedIn). This will allow multiple concurrent users to sign in, maintain their own profiles, save personalized itineraries, and request matches against each other.

2. Semantic Search & Vector Embeddings (RAG)

• Current State: AI recommendations are computed on-the-fly by feeding JSON payloads directly into LLM prompts, or matched via keyword heuristics.

• Improvement: Generate vector embeddings for all sessions, sponsors, and user profiles. Store them in Supabase using pgvector. This enables Semantic RAG (Retrieval-Augmented Generation), making recommendation scoring much faster and more accurate while reducing prompt token costs.

3. Dynamic Scraping with Headless Browsers

• Current State: The URL scraper uses standard Python HTTP requests. It fails on conference websites that require JavaScript to render (SPAs).

• Improvement: Integrate a headless browser engine like Playwright or Selenium into the backend. This will allow the AI Scraper to wait for client-side JavaScript to render before extracting the schedule text.

4. Integration with Calendar Apps (Google, Outlook, Apple)

• Current State: The personalized schedule is stored locally and visualized on the Kendo React Scheduler.

• Improvement: Expose an endpoint to export the optimized schedule as an .ics file or direct sync via Google Calendar API, letting users view their conference plans alongside their daily calendars.

5. Automated LinkedIn & GitHub Onboarding

• Current State: Users must manually type their goals, interests, and stack into the profile configuration.

• Improvement: Let users log in with GitHub or LinkedIn and auto-populate their bio, skills, repository languages, and work experience using the LLM to analyze their social profiles.

6. Progressive Web App (PWA) / Mobile Support

• Current State: The frontend is optimized for desktop and responsive web layouts.

• Improvement: Add PWA manifest files and service workers to make the application installable on mobile devices, ensuring offline access to schedules on spotty convention center Wi-Fi.