A Step-by-Step Coding Guide to Building a Gemini-Powered AI Startup Pitch Generator Using LiteLLM Framework, Gradio, and FPDF in Google Colab with PDF Export Support

In this tutorial, we built a powerful and interactive AI application that generates startup pitch ideas using Google’s Gemini Pro model through the versatile LiteLLM framework. LiteLLM is the backbone of this implementation, providing a unified interface to interact with over 100 LLM providers using OpenAI-compatible APIs, eliminating the complexity of dealing with individual SDKs. By leveraging LiteLLM, we seamlessly connected to Gemini’s capabilities for creative ideation and wrapped the outputs into a user-friendly Gradio interface. Also, we used FPDF to generate polished, Unicode-compatible PDFs containing the full startup pitch deck. This tutorial demonstrates how modern AI tooling, including LiteLLM, Gradio, Google Generative AI, and FPDF, can build an end-to-end solution for entrepreneurs, innovators, and developers.

!pip install litellm gradio fpdf --quiet

!pip install litellm gradio fpdf –quiet installs the core libraries needed for this project. It brings in LiteLLM for interacting with Gemini via a unified API, Gradio for creating a simple web interface, and FPDF for exporting the AI-generated pitch into a well-formatted PDF file—all while suppressing verbose installation logs with –quiet.

import os
import gradio as gr
import uuid
import urllib.request
from fpdf import FPDF
from litellm import completion


api_key = "Your API Key"

We import all the essential Python libraries used in the project, including os for file operations, uuid for generating unique filenames, and urllib for downloading fonts. We also initialize Gradio for the UI, FPDF for PDF creation, and LiteLLM’s completion function to interface with Gemini. The api_key variable stores the user’s Gemini API key, which is required to authenticate requests.

import urllib.request
import zipfile
import os
import shutil


if not os.path.exists("DejaVuSans.ttf"):
    print(" Downloading DejaVuSans.ttf...")
    font_zip_url = "https://downloads.sourceforge.net/project/dejavu/dejavu/2.37/dejavu-fonts-ttf-2.37.zip"
    font_zip_path = "dejavu-fonts.zip"


    urllib.request.urlretrieve(font_zip_url, font_zip_path)


    with zipfile.ZipFile(font_zip_path, 'r') as zip_ref:
        zip_ref.extractall("dejavu-extracted")


    for root, dirs, files in os.walk("dejavu-extracted"):
        for file in files:
            if file == "DejaVuSans.ttf":
                ttf_path = os.path.join(root, file)
                shutil.copy(ttf_path, "DejaVuSans.ttf")
                print(" Font extracted and ready.")
                break

Here, we ensure that the DejaVuSans.ttf font is available to create Unicode-compatible PDFs. It downloads the font zip file from SourceForge, extracts its contents, and copies the .ttf file to the working directory. This step is crucial for handling special characters from Gemini’s output when generating the final pitch PDF using FPDF.

def call_gemini(system_prompt, user_prompt):
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_prompt}
    ]
    response = completion(
        model="gemini/gemini-2.0-flash-lite",
        messages=messages,
        api_key=api_key
    )
    return response["choices"][0]["message"]["content"]

This function, call_gemini, is a wrapper that uses LiteLLM’s completion API to interact with the Gemini 2.0 Flash Lite model. It accepts a system prompt and a user prompt, structures them in OpenAI-compatible format, sends the request using the provided API key, and returns the generated response—making it easy to reuse across various application parts.

def generate_startup_pitch(theme):
    try:
        idea_prompt = f"Generate an innovative startup idea in the field of {theme}. Focus on solving real problems using modern technology."
        tagline_prompt = "Based on the idea you just gave, generate a short, catchy tagline for the startup."
        pitch_prompt = """
        Based on the previous startup idea, write a concise pitch deck covering:
        1. Problem
        2. Solution
        3. Market Opportunity
        4. Team Description
        5. Business Model
        6. Traction or Future Plan
        Format it in a way that looks like slide notes for a VC pitch.
        """


        idea = call_gemini("You are an innovation strategist.", idea_prompt)
        tagline = call_gemini("You are a branding expert.", tagline_prompt)
        pitch = call_gemini("You are a startup mentor writing a pitch deck.", pitch_prompt)


        filename = f"startup_pitch_{uuid.uuid4().hex[:8]}.pdf"
        pdf = FPDF()
        pdf.add_page()
        pdf.add_font("DejaVu", "", font_path, uni=True)
        pdf.set_font("DejaVu", size=12)


        full_text = f"Startup Idea:n{idea}nnTagline:n{tagline}nnPitch Deck:n{pitch}"
        pdf.multi_cell(0, 10, full_text)
        pdf.output(filename)


        return idea, tagline, pitch, filename
    except Exception as e:
        return f" Error: {e}", "", "", None

The generate_startup_pitch function orchestrates the entire startup generation process. It sends tailored prompts to Gemini via LiteLLM to produce a startup idea, a catchy tagline, and a structured pitch deck. The responses are then combined into a formatted PDF using FPDF, with proper Unicode support via the DejaVu font. The PDF is saved with a unique filename, enabling users to download their personalized pitch. Error handling ensures smooth execution and user feedback in case of failures.

with gr.Blocks() as demo:
    gr.Markdown("#  AI Startup Pitch Generator (with PDF Export)")
    theme_input = gr.Textbox(label="Enter a theme or industry", placeholder="e.g., mental health, fintech, climate tech")


    generate_button = gr.Button("Generate Pitch")


    idea_output = gr.Textbox(label="Startup Idea")
    tagline_output = gr.Textbox(label="Tagline")
    pitch_output = gr.Textbox(label="Pitch Deck Summary", lines=10)
    pdf_output = gr.File(label="Download Pitch as PDF")


    def wrapper(theme):
        idea, tagline, pitch, pdf_path = generate_startup_pitch(theme)
        return idea, tagline, pitch, pdf_path


    generate_button.click(fn=wrapper, inputs=theme_input, outputs=[idea_output, tagline_output, pitch_output, pdf_output])


demo.launch(share=True)

We defined the Gradio user interface for the AI Startup Pitch Generator. Using gr.Blocks() creates a clean layout with an input box for the user to enter a startup theme or industry and a button to trigger the pitch generation. Once clicked, the wrapper function calls generate_startup_pitch, returning a startup idea, tagline, pitch summary, and a downloadable PDF. The share=True flag enables public access to the app, making it easy to demo or share the tool with others via a unique URL.

App Interface to Generate Ideas

In conclusion, by combining the abstraction power of LiteLLM with the creative intelligence of Google’s Gemini Pro, this tutorial highlights how developers can rapidly prototype intelligent, production-ready applications. LiteLLM drastically simplifies working with diverse LLM APIs by maintaining a consistent OpenAI-style calling interface across providers like Gemini, Claude, OpenAI, and more. Through Gradio, we added an intuitive front end to accept user input and display results, while FPDF allowed us to convert AI-generated content into shareable, well-formatted PDF documents. This tutorial showcases how to build a multi-component AI app in a Colab-friendly environment and underlines LiteLLM’s role as a pivotal gateway to the expanding ecosystem of language models. Whether you’re building MVPs or production tools, LiteLLM offers the flexibility and scalability to keep your LLM workflow fast and future-proof.

Here is the Colab Notebook. Also, don’t forget to follow us on Twitter and join our Telegram Channel and LinkedIn Group. Don’t Forget to join our 85k+ ML SubReddit.

[Register Now] miniCON Virtual Conference on OPEN SOURCE AI: FREE REGISTRATION + Certificate of Attendance + 3 Hour Short Event (April 12, 9 am- 12 pm PST) + Hands on Workshop [Sponsored]

The post A Step-by-Step Coding Guide to Building a Gemini-Powered AI Startup Pitch Generator Using LiteLLM Framework, Gradio, and FPDF in Google Colab with PDF Export Support appeared first on MarkTechPost.

Source: Read More