How to build an event assistant in under 1 hour using Open AI and Vercel, part II

Val Brodsky — Fri, 02 May 2025 23:01:25 +0000

Deploying Your OpenAI Assistant Chat to Vercel

In the previous post, we built an AI Event Assistant using OpenAI's tools and prompts. Now, let's create a simple chat interface for it and make it publicly accessible using Vercel.

1.Start with the Quickstart:
Begin by cloning the official OpenAI Assistants Quickstart repository:
https://github.com/openai/openai-assistants-quickstart

2. Handle OpenAI Library Updates:
I encountered an incompatibility when using a newer version of the OpenAI Node.js library (v4.90.0) than the quickstart likely targeted (around v4.46.0, based on its package.json). Specifically, openai.beta.vectorStores needed to be updated to openai.vectorStores. Check your library version and adjust the code accordingly.

3. Improve User Experience During Waits:
The default UI is basic. Since Assistant API calls can sometimes take a noticeable amount of time (often >10 seconds in my tests), I added a simple "Waiting..." indicator. This appears while the assistant processes a request, letting the user know the app hasn't stalled.

4. Address Vercel Timeouts:
When deploying to Vercel, I initially ran into requests timing out. OpenAI Assistant API calls can exceed Vercel's default serverless function timeout (10 seconds for Hobby/Pro tiers). To resolve this, you need to increase the maximum duration for the function handling the Assistant API calls. Add the following line to the top of your relevant API route file (e.g., in Next.js):

export const maxDuration = 60; // Increase timeout to 60 seconds

See the Code:
You can view all my modifications compared to the original quickstart here:
https://github.com/vbrodsky/openai-kabbalah-app

With these changes, you should be ready to deploy your repository to a Vercel project and get a free public URL for your AI assistant. Good luck!

How to build an event assistant in under 1 hour using Open AI and Vercel, part I

Val Brodsky — Fri, 18 Apr 2025 22:35:58 +0000

Introduction

Navigating complex event schedules like the one my non-profit client hosts can be confusing for attendees trying to register. What if an AI could act as a helpful guide? In this post, I'll show you how to quickly build such an AI event assistant, and in the follow up part II I will provide a way to quickly build and deploy it as a simple chat page. All under 4 hours using OpenAI and Vercel.

An OpenAI assistant

has instructions and can leverage models, tools, and files to respond to user queries.

Think of it as a specialized chatbot, equipped with specific instructions and tools or documents to answer complex queries accurately.

For this proof-of-concept, we'll focus on helping users navigate the week-long event with its multiple sessions, venues, and pricing tiers.

Steps to build an assistant

This section outlines the process using the OpenAI Platform UI (specifically the Assistants and Playground sections).

Create an Account
First, ensure you have an OpenAI account and have set up billing on the OpenAI Platform. While you might also have a ChatGPT Plus subscription, using the API, Assistants, and Playground requires adding a payment method under your organization's Billing settings. This enables pay-as-you-go usage for the models and tools. Setting up billing also creates an Organization, allowing you to manage usage and potentially invite team members. You may want to set usage limits in your billing settings to control costs.

Create an Assistant
Navigate to the OpenAI Platform and select "Assistants" from the left-hand menu.

Click the "+ Create" button.
Name: Give your assistant a descriptive name (e.g., "Event Info Assistant").
Instructions: Leave the instructions empty for now – we'll add these in the prompt refinement step.
Model: Select a suitable model. gpt-4o-mini is a great choice for balancing capability and cost.
Tools: We'll enable tools in the next step.
Model Configuration: You can typically leave Temperature and Top P at their default settings for now.
Click Save.

Upload Content
Our assistant needs knowledge about the specific event. We'll provide this using the File Search tool.

On your newly created Assistant's configuration page, go to the Tools section.
Enable File Search.
Under Files, click "Upload" and add the relevant documents. For this POC, I gathered information from various sources and saved them as files (e.g., .html, .txt):
- Event schedule and location (saved from web page)
- Event description (saved from web page)
- Contextual information about event activities (saved from web page)
- Pricing details (copied into a text file from the registration site)
- Swag purchasing info (copied from a marketing email into a text file)

Tip: While I initially wrote a Python script to scrape and clean HTML content, I found OpenAI's File Search handles raw HTML files quite well, often making pre-processing unnecessary. You can upload various formats like PDF, DOCX, HTML, TXT, etc. Check the OpenAI documentation for supported file types.

Create and Refine Prompt

Now, let's give our assistant its personality and operating instructions via the System Instructions.

Drafting: You can draft instructions from scratch, or even get inspiration by summarizing your uploaded documents and asking another AI (like Claude, ChatGPT, or even your base OpenAI model via the Chat Playground) to generate a starting point based on the desired role. For this assistant, I started with an AI-generated draft based on the core event details and then refined it.
Adding Instructions: Go back to your Assistant's configuration page on the OpenAI Platform, and paste your refined instructions into the Instructions field. Save the changes.
Testing & Iteration: The key to a good assistant is testing! Use the Playground (also available on the OpenAI Platform) to interact with your assistant. Select your assistant from the dropdown menu in the Playground.
- Test Queries: Ask various questions to see how it responds, checking for accuracy, tone, and adherence to instructions. Here are some examples I used:
  - when and where is the event?
  - when does the registration discount end?
  - what is the registration url?
  - what if I bring a nanny to the event, do I need to pay for her?
  - what are the most important sessions to attend?
  - what is the importance of the event and who should definitely attend?
  - what are the cheap hotels in the area? (Note: The base model might answer this using its general knowledge, even if not in your files. File Search augments the model.)
  - tell me more about the organization running the event and why are they better doing it than someone else? (This helped identify the need for guardrails).
- Refine: Based on the responses, go back and tweak the System Instructions. Clarify ambiguous points, add constraints, or adjust the tone. Repeat testing until you're satisfied. We used this process to add "content guardrails" (see Limitations in the prompt structure below) to prevent off-topic or comparative questions.

Prompt Structure
After iteration, we arrived at a prompt structure similar to this (abridged):

System Instructions for <Org Name> Scheduling Assistant

You are a specialized scheduling assistant for the <org name>, designed to help users with event information, registration, pricing details, and scheduling for the main <even name> event in Los Angeles. Your primary purpose is to make the process of finding and registering for events simple and efficient.

## Core Knowledge and Capabilities
* Provide accurate information about upcoming <event name>
* Help users understand pricing structures, including early bird and regular pricing options
* Assist with registration processes and deadlines
* Provide location details for both in-person and virtual events
* Explain event agendas, schedules, and special offerings

## Tone and Style
* Be warm, informative, and supportive
* Communicate with clarity and respect
* Be conversational but precise with event details, especially regarding dates, times, and prices
* Reflect the spiritual nature of the <org name> while being practical about logistics
* Be patient and thorough when explaining complex pricing structures or registration processes

## Response Framework
When a user inquires about an event:
1. **Acknowledge their interest** in the specific event or type of event
2. **Provide core details** about the event (date, time, location, format)
3. **Explain pricing options** when relevant, especially early bird and regular pricing differences
4. **Share registration process** and any deadlines they should be aware of
5. **Offer additional information** about the event content, agenda, or spiritual significance

## Limitations (Content Guardrails)
* You do not have the ability to directly register users for events; instead, direct them to registration links
* You cannot process payments or hold spots for users
* You don't have access to real-time availability for events
* You cannot create new events or modify existing event details
* You cannot access personal user account information
* You do not answer general questions not related directly to events or what the events are all about, like ...
* You do not answer questions about events other than <event name>

## Special Knowledge (From Files)
* You understand the ... Scholarship Fund and can explain how users can apply for assistance
* You can explain the difference between in-person and virtual events
* You know that some events have translation services available in multiple languages

Always strive to be helpful, accurate, and respectful within the boundaries of these instructions and the provided knowledge files.

Our Assistant is now configured and performing well in the OpenAI Playground. The next logical step is to share it with stakeholders for review and testing. However, the Playground requires individual OpenAI accounts, making wider access difficult. To bridge this gap, the next article will demonstrate how to build a simple React chat page, connect it to our assistant, and deploy it on Vercel, making it accessible to anyone with a link.

DEV Community: Val Brodsky

How to build an event assistant in under 1 hour using Open AI and Vercel, part II

How to build an event assistant in under 1 hour using Open AI and Vercel, part I

Introduction

Steps to build an assistant