Venti.ai_ArianaVenti67

Your excellent personal work buddy

Comment

Venti.ai — The AI Copilot for Modern Financial Advisors

Venti.ai brings client management, intelligent scheduling, professional learning, partner referrals, and AI-powered insights into one connected advisory platform.

Inspiration

Financial advisors do much more than provide financial advice. They manage client records, prepare for meetings, follow up on conversations, complete professional learning, coordinate referrals, and maintain long-term client relationships.

However, these activities are often spread across disconnected applications, spreadsheets, calendars, chat platforms, and handwritten notes. This makes it difficult for advisors to find important information, prepare effectively for meetings, and identify the next best action for each client.

Client scheduling and service enquiries can also be manual and time-consuming. Advisors may spend valuable time answering repeated questions, collecting appointment details, and entering information into calendars.

We built Venti.ai to solve this problem.

Instead of creating another traditional customer relationship management system, we designed an AI-assisted advisory copilot that connects advisor workflows with an automated client touchpoint. Vanti.ai helps advisors organise information, reduce repetitive work, strengthen client relationships, and make more informed decisions.

The Solution

Venti.ai combines an advisor-facing web platform with a client-facing Telegram bot.

Advisor Web Platform

The web application provides advisors with several connected modules:

  • Dashboard — Displays meetings, tasks, action items, schedules, and AI-generated morning briefings.
  • Client Memory — Stores client profiles, notes, interaction histories, meeting records, and important relationship information.
  • Learning Hub — Provides professional learning materials and tracks advisor progress.
  • AI Assistance — Generates meeting summaries, client insights, follow-up recommendations, learning support, and partner matches.

Telegram Client Assistant

The Telegram bot acts as an accessible client-facing bridge to the platform.

Clients can use natural language to:

  • Ask about available services
  • Submit enquiries
  • Book appointments
  • Update appointment details
  • Receive follow-up messages
  • Provide interaction data for advisor review

The advisor remains the main user of the platform, while clients can interact with selected services through Telegram without requiring access to the complete internal system.

How We Built It

We designed Venti.ai using a distributed and layered system architecture that connects React, Java, Python, relational databases, AI services, and external APIs.

1. Advisor Web Application

The frontend was developed using React and Vite. It provides the interface for the Dashboard, Client Memory, Learning Hub, Partner Finder, and settings.

A Node.js middleware service supports calendar-related requests and integrations.

The web interface communicates with the backend through HTTP requests using structured JSON data.

2. Spring Boot Backend

The primary backend was developed using Java 17 and Spring Boot.

The REST API follows a layered architecture:

  • Controller layer — Receives and responds to API requests
  • Service layer — Processes application and business logic
  • Repository layer — Communicates with the database
  • DTO layer — Controls request and response structures
  • Validation layer — Rejects incomplete or invalid input
  • Exception handling — Returns consistent and meaningful error responses

We used Spring Data JPA and Hibernate to connect the backend to a central MySQL/MariaDB database.

The database stores:

  • Advisor profiles
  • Client records
  • Meetings
  • Tasks
  • Client interactions
  • Learning progress
  • AI-generated summaries and conversations

3. Telegram Bot Engine

The Telegram assistant was developed in Python using pyTelegramBotAPI.

It runs asynchronously so that several clients can interact with the bot without one conversation blocking another.

The bot connects to the Grafilab LLM API, using the Qwen model through the OpenAI-compatible Python SDK.

We used Pydantic to transform natural-language requests into validated structured data. For example, a message such as:

“Book me a meeting next Monday afternoon.”

can be converted into structured appointment information containing the date, time, client details, and service request.

4. Calendar and Follow-Up Automation

The Telegram bot connects to the Google Calendar API using service-account authentication.

This allows the system to:

  • Create appointments
  • Update existing appointments
  • Check scheduling information
  • Store calendar event references

A lightweight SQLite database records bot conversations and interaction data.

A background follow-up script periodically checks inactive enquiries and identifies clients who may require re-engagement.

System Architecture

┌────────────────────┐                 ┌────────────────────┐
│      Advisor       │                 │  Telegram Client   │
└─────────┬──────────┘                 └─────────┬──────────┘
          │                                      │
          ▼                                      ▼
┌────────────────────┐                 ┌────────────────────┐
│ React / Vite Web UI│                 │ Python Bot Engine  │
└─────────┬──────────┘                 └──────┬──────┬──────┘
          │ HTTP / JSON                       │      │
          ▼                                   │      ├────────► Grafilab LLM
┌────────────────────┐                        │      │
│  Spring Boot API   │                        ▼      ▼
└─────────┬──────────┘                 ┌──────────┐ ┌────────────────┐
          │ JPA / Hibernate            │ SQLite  │ │ Google Calendar│
          ▼                            └──────────┘ └────────────────┘
┌────────────────────┐
│  MySQL / MariaDB   │
└────────────────────┘

Repository Structure

venti-ai/
├── frontend/             # React and Vite web application
├── backend/              # Java and Spring Boot REST API
├── database/             # Relational database schema
├── telegram-bot/         # Python bot and follow-up engine
│   ├── bot.py
│   ├── followup.py
│   └── requirements.txt
├── README.md
└── .gitignore

What We Learned

Building Vanti.ai taught us how multiple technologies and programming ecosystems can work together as one complete platform.

Structured AI Outputs

Natural-language responses generated by an LLM are not always predictable enough for direct use in backend operations.

We learned to use Pydantic validation models to convert AI output into reliable JSON structures before sending information to services such as Google Calendar.

This helped us distinguish between:

  • Generating human-readable AI responses
  • Producing machine-readable data
  • Validating generated information before performing an action

Asynchronous Python Development

A client-facing bot must support several simultaneous conversations.

We learned how asynchronous programming can prevent long-running API calls from blocking other bot users. This was especially important when the system communicated with both an LLM service and the Google Calendar API.

Full-Stack API Development

We gained practical experience building a structured Spring Boot application using:

  • Entities
  • Repositories
  • Services
  • Controllers
  • DTOs
  • Input validation
  • Global exception handling

We also learned how frontend data requirements influence backend endpoint design and relational database relationships.

External API Authentication

We learned how service-account authentication supports server-to-server communication with Google Calendar without requiring every client to complete an individual OAuth login process.

Cross-Technology Integration

One of our most important lessons was learning how to organise React, Java, Python, MySQL, SQLite, and external APIs inside one GitHub monorepo.

Each technology performs a different responsibility, but they must follow consistent data structures and communication rules to operate as one system.

Challenges We Faced

Cross-Language Data Alignment

The Spring Boot backend uses Java objects and MySQL, while the Telegram bot uses Python models and SQLite.

Maintaining consistent structures for client identifiers, meeting dates, interaction records, and appointment statuses across these environments was challenging.

We addressed this by defining clear data fields and using structured request and response formats.

Natural-Language Date Interpretation

Clients may use expressions such as:

  • “Tomorrow morning”
  • “Next Monday afternoon”
  • “After lunch”
  • “Sometime next week”

These phrases do not contain exact timestamps.

The system had to interpret them according to the correct time zone and convert them into valid date-time values suitable for Google Calendar. We also had to prevent ambiguous AI outputs from creating incorrect appointments.

UI and Database Evolution

As the web interface developed, the required database fields and relationships also changed.

Features shown in the UI needed corresponding backend entities, API endpoints, and database tables. At the same time, information submitted through the Telegram bot had to follow the same constraints.

This required continuous coordination between the interface design, backend logic, and database structure.

Environment and Dependency Configuration

The project combined different development environments and dependencies:

  • Java and Maven
  • Spring Boot and Hibernate
  • Python packages
  • Google API clients
  • Node.js packages
  • MySQL/MariaDB
  • SQLite

We faced compatibility issues, dependency mismatches, database configuration errors, Java compilation problems, and environment-variable management challenges.

Resolving these problems taught us the importance of clear configuration files, dependency documentation, and isolated development environments.

Security and Secret Management

The project required access to database credentials, LLM API keys, Telegram bot tokens, and Google service-account credentials.

These values could not be stored directly in the GitHub repository.

We learned to use environment variables, .gitignore, and local configuration files to prevent sensitive credentials from being committed publicly.

Our Accomplishments

We successfully:

  • Designed an architecture connecting React, Spring Boot, Python, AI services, and relational databases
  • Implemented a Client Memory CRUD API
  • Connected Spring Boot to MySQL/MariaDB using JPA and Hibernate
  • Added input validation and centralised API exception handling
  • Built a Telegram bot capable of understanding natural-language enquiries
  • Converted AI responses into validated structured appointment data
  • Integrated automated booking with Google Calendar
  • Created a local interaction logger using SQLite
  • Developed a follow-up process for dormant enquiries
  • Organised the project as a GitHub monorepo
  • Prepared the system for future deployment and deeper AI integration

What Is Next

Our next development phase will focus on connecting all platform components into a more unified production system.

Planned improvements include:

  • Moving Telegram interaction data from SQLite into the central MySQL database
  • Connecting the Telegram bot to Spring Boot using secure REST endpoints
  • Displaying Telegram conversation histories inside Client Memory
  • Adding Spring Security authentication and role-based access control
  • Implementing secure permission rules for bot-generated booking requests
  • Generating personalised advisor morning briefings
  • Developing predictive follow-up recommendations
  • Connecting client history, learning content, and conversations to AI-assisted insights
  • Adding monitoring, testing, containerisation, and cloud deployment

Conclusion

Venti.ai is more than a scheduling bot or client-record system. It is an AI-assisted advisory ecosystem designed to connect advisor workflows with accessible client interactions.

By combining React, Spring Boot, Python, MySQL/MariaDB, SQLite, Google Calendar, and large language models, Vanti.ai reduces repetitive administrative work and gives advisors more time to focus on meaningful client relationships.

Venti.ai helps financial advisors remember more, respond faster, and advise smarter.

Built With

Share this project:

Updates

Submission history