The Era of Full-Stack Applications on a Budget

Remember the days when developing a full-stack application required expensive cloud credits, costly API keys, and a team of skilled engineers? Those days seem to be behind us. Indeed, by 2026, developers will have the ability to build, deploy, and scale production-ready applications using only free tools. Among these tools, large language models (LLMs) play a central role by providing the necessary intelligence at no additional cost.

The tech landscape has undergone a radical transformation. Open-source models, once considered inferior to their commercial counterparts, are now on par. Free AI coding assistants have evolved beyond simple code completion tools to become true development agents capable of designing entire features. One of the most revolutionary aspects is the ability to run cutting-edge models locally or via generous free tiers, without spending a dime.

In this article, we will explore the construction of a concrete application: an AI meeting notes synthesizer. This application will allow users to upload voice recordings, which our system will transcribe, summarize, and analyze to extract key points and action items. The entire process will be carried out using only free tools.

Whether you are a student, a bootcamp graduate, or an experienced developer looking to prototype an idea, this tutorial will show you how to leverage the best free AI tools available today. Let's start by understanding why free LLMs work so well today.

Understanding Why Free Large Language Models Work Now

Just two years ago, creating an AI-powered application meant budgeting for OpenAI API credits or renting costly GPU instances. The economy has fundamentally changed. The gap between commercial and open-source LLMs has nearly vanished. Models like GLM-4.7-Flash from Zhipu AI demonstrate that open-source can achieve state-of-the-art performance while being completely free to use. Similarly, LFM2-2.6B-Transcript has been specifically designed for meeting synthesis and operates entirely on-device with cloud-equivalent quality.

This means you are no longer tied to a single provider. If one model does not work for your use case, you can switch to another without changing your infrastructure.

Joining the Self-Hosting Movement

There is a growing preference for local AI running models on your own hardware rather than sending data to the cloud. This is not just a matter of cost; it’s about privacy, latency, and control. With tools like Ollama and LM Studio, you can run powerful models on a laptop.

Embracing the "Bring Your Own Key" Model

A new category of tools has emerged: open-source applications that are free but require you to provide your own API keys. This offers you ultimate flexibility. You can use Google’s Gemini API (which offers hundreds of free queries per day) or run fully local models with no recurring costs.

Choosing Your Free AI Stack

Breaking down the best free options for each component of our application involves selecting tools that balance performance and ease of use.

Transcription Layers: Speech-to-Text

To convert audio to text, we have excellent free speech-to-text (STT) tools. Among them, Whisper stands out for its ability to be run locally or via free hosting options. It supports over 100 languages and produces high-quality transcriptions.

Summarization and Analysis: The Large Language Model

This is where you have the most choices. All the options below are completely free:

• Cloud (Free API)
• General usage, coding
• LFM2-2.6B-Transcript
• Meeting synthesis
• Gemini 1.5 Flash
• Long context, free tier
• Local/self-hosted
• Japanese/English reasoning

For our meeting synthesizer, the LFM2-2.6B-Transcript model is particularly interesting; it has been specifically trained for this exact use case and operates with less than 3 GB of RAM.

Accelerating Development: AI Coding Assistants

Before writing a single line of code, let’s consider the tools that help us build more efficiently within the integrated development environment (IDE):

• VS Code Extension
  • Specification-based, multi-agent
  • Over 70 languages, fast inference
• VS Code Extension
  • Standalone file editing
  • Fully open-source
  • Works with any LLM
  • Full-stack generation

Our recommendation: For this project, we will use Codeium for its unlimited free tier and speed, and we will keep Continue as a backup solution for times when we need to switch between different LLM providers.

Review of the Traditional Free Stack

• Frontend: React (free and open-source)
• Backend: FastAPI (Python, free)
• Database: SQLite (file-based, no server needed)
• Deployment: Vercel (generous free tier) + Render (for the backend)

Project Plan Review

Define the application workflow:

• The user uploads an audio file (meeting recording, voice memo, lecture)
• The backend receives the file and sends it to Whisper for transcription
• The transcribed text is sent to an LLM for summarization
• The LLM extracts key discussion points, action items, and decisions
• The results are stored in SQLite
• The user sees a clear dashboard with the transcription, summary, and action items

Prerequisites

• Python 3.9+ installed
• Node.js and npm installed
• Basic familiarity with Python and React
• A code editor (VS Code recommended)

Step 1: Setting Up the Backend with FastAPI

First, create our project directory and set up a virtual environment:

mkdir meeting-summarizer
cd meeting-summarizer
python -m venv venv

Activate the virtual environment:

venv\Scripts\activate

On Linux/macOS

source venv/bin/activate

Install the required packages:

pip install fastapi uvicorn python-multipart openai-whisper transformers torch openai

Now, create the main.py file for our FastAPI application and add this code:

from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from datetime import datetime

# Enable CORS for the React frontend
app.add_middleware(
    allow_origins=["http://localhost:3000"],
    allow_methods=["*"],
    allow_headers=["*"],
)

# Initialize the Whisper model - using "tiny" for faster CPU processing
print("Loading Whisper model (tiny)...")
model = whisper.load_model("tiny")
print("Whisper model loaded!")

# Database setup
conn = sqlite3.connect('meetings.db')
c = conn.[cursor](/outil/cursor)()
c.execute('''CREATE TABLE IF NOT EXISTS meetings
(id INTEGER PRIMARY KEY AUTOINCREMENT,
transcript TEXT,
action_items TEXT,
created_at TIMESTAMP)''')

async def summarize_with_llm(transcript: str) -> dict:
    """Placeholder for LLM summarization logic"""
    # This will be implemented in step 2
    return {"summary": "Summary pending...", "action_items": []}

@app.post("/upload")
async def upload_audio(file: UploadFile = File(...)):
    file_path = f"temp_{file.filename}"
    with open(file_path, "wb") as buffer:
        content = await file.read()
        buffer.write(content)

    # Step 1: Transcribe with Whisper
    result = model.transcribe(file_path, fp16=False)
    transcript = result["text"]

    # Step 2: Summarize (To be filled in step 2)
    summary_result = await summarize_with_llm(transcript)

    # Step 3: Save to the database
    conn = sqlite3.connect('meetings.db')
    c = conn.cursor()
    c.execute("INSERT INTO meetings (filename, transcript, summary, action_items, created_at) VALUES (?, ?, ?, ?, ?)",
              (file.filename, transcript, summary_result["summary"],
               json.dumps(summary_result["action_items"]), datetime.now()))
    meeting_id = c.lastrowid
    os.remove(file_path)

    return {
        "id": meeting_id,
        "transcript": transcript,
        "summary": summary_result["summary"],
        "action_items": summary_result["action_items"]
    }

Step 2: Integrating the Free Large Language Model

Now, let’s implement the summarize_with_llm() function. We will show two approaches:

Option A: Using the GLM-4.7-Flash API (Cloud, Free)

from openai import OpenAI

async def summarize_with_llm(transcript: str) -> dict:
    client = OpenAI(api_key="YOUR_FREE_ZHIPU_KEY", base_url="https://open.bigmodel.cn/api/paas/v4/")
    response = client.chat.completions.create(
        model="glm-4-flash",
        messages=[
            {"role": "system", "content": "Summarize the following meeting transcript and extract action items in JSON format."},
            {"role": "user", "content": transcript}
        ],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

Option B: Using LFM2-2.6B-Transcript Locally (Local, Completely Free)

from transformers import AutoModelForCausalLM, AutoTokenizer

async def summarize_with_llm_local(transcript):
    model_name = "LiquidAI/LFM2-2.6B-Transcript"
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(
        torch_dtype=torch.float16,
        device_map="auto"
    )
    [prompt](/glossaire/prompt) = f"Analyze this transcript and provide a summary and action items:\n\n{transcript}"
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model.generate(**inputs, max_new_tokens=500)
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

Step 3: Creating the React Frontend

Build a simple React frontend to interact with our API. In a new terminal, create a React application:

npx create-react-app frontend
npm install axios

Replace the content of src/App.js with:

import React, { useState } from 'react';
import axios from 'axios';
import './App.css';

function App() {
    const [file, setFile] = useState(null);
    const [uploading, setUploading] = useState(false);
    const [result, setResult] = useState(null);
    const [error, setError] = useState('');

    const handleUpload = async () => {
        if (!file) { 
            setError('Please select a file'); 
            return; 
        }
        setUploading(true);
        const formData = new FormData();
        formData.append('file', file);
        try {
            const response = await axios.post('http://localhost:8000/upload', formData);
            setResult(response.data);
        } catch (err) {
            setError('Upload failed: ' + (err.response?.data?.detail || err.message));
        } finally { 
            setUploading(false); 
        }
    }

    return (
        <div className="App">
            <header className="App-header"><h1>AI Meeting Synthesizer</h1></header>
            <main className="container">
                <div className="upload-section">
                    <input type="file" onChange={(e) => setFile(e.target.files[0])} />
                    <button onClick={handleUpload} disabled={uploading}>
                        {uploading ? 'Uploading...' : 'Upload'}
                    </button>
                </div>
                {error && <p className="error">{error}</p>}
                {result && (
                    <div className="result">
                        <h2>Result</h2>
                        <p><strong>Transcription:</strong> {result.transcript}</p>
                        <p><strong>Summary:</strong> {result.summary}</p>
                        <p><strong>Action Items:</strong> {result.action_items.join(', ')}</p>
                    </div>
                )}
            </main>
        </div>
    );
}

This code sets up a simple user interface for uploading audio files and displaying the results of the analysis.