{"id":4878,"date":"2025-03-19T09:00:10","date_gmt":"2025-03-19T08:00:10","guid":{"rendered":"https:\/\/www.hiberus.com\/en\/blog\/?p=4878"},"modified":"2025-08-06T13:30:24","modified_gmt":"2025-08-06T11:30:24","slug":"building-an-ai-powered-expense-tracking-system-with-gradio-pydantic-ai-supabase-and-deepseek-a-comprehensive-guide","status":"publish","type":"post","link":"https:\/\/www.hiberus.com\/en\/blog\/building-an-ai-powered-expense-tracking-system-with-gradio-pydantic-ai-supabase-and-deepseek-a-comprehensive-guide\/","title":{"rendered":"Building an AI-Powered Expense Tracking System with Gradio, Pydantic-AI, Supabase and DeepSeek: A Comprehensive Guide"},"content":{"rendered":"

Have you ever wondered how to leverage AI to track your expenses effortlessly? Join me, Abbaoui Achraf, ML Engineer passionate about AI applications, as we build an AI-powered expense tracking application<\/strong> using cutting-edge tools like DeepSeek<\/strong>, Gradio<\/strong>, Pydantic<\/strong>, Pydantic-AI<\/strong>, and Supabase<\/strong>. Together, we’ll create a smart system that not only helps users manage their expenses but also provides intelligent insights about their spending patterns\u2014all while keeping their data secure in a Supabase<\/strong> database.<\/p>\n

Why Supabase?<\/h3>\n

Supabase<\/strong> provides a seamless backend-as-a-service solution, offering real-time PostgreSQL databases, authentication, and more. It\u2019s an excellent choice for this project because it allows us to focus on the application logic and the AI agent rather than worrying about setting up and managing our own database.<\/p>\n

Let\u2019s get started!<\/p>\n

1. Setting Up the Environment<\/h2>\n

First, install the required libraries to set up the project. Open a terminal and run:<\/p>\n

pip install gradio pydantic pydantic-ai supabase logfire\r\n<\/code><\/pre>\n
Once the libraries are installed, we can start configuring the environment.<\/p>\n
2. Configuring Logging<\/h2>\n
Before diving into the main app, it’s good practice to set up logging to track any issues or operations. This helps with debugging and maintaining the application.<\/p>\n
import logfire\r\nlogfire.configure()\r\n<\/code><\/pre>\n
3. Defining Data Models with Pydantic<\/h2>\n
We need to define the data models that represent the structure of the expenses. These models ensure that we maintain consistent and valid data throughout the app.<\/p>\n
Defining Expense Categories<\/h3>\n
We define the different categories of expenses, such as food<\/strong>, transport<\/strong>, etc.<\/p>\n
from enum import Enum\r\n\r\nclass ExpenseCategory(str, Enum):\r\n    FOOD = \"food\"\r\n    TRANSPORT = \"transport\"\r\n    ENTERTAINMENT = \"entertainment\"\r\n    UTILITIES = \"utilities\"\r\n    RENT = \"rent\"\r\n    OTHER = \"other\"\r\n<\/code><\/pre>\n
Creating the Expense Base Model<\/h3>\n
This is the model that represents a single expense entry:<\/p>\n
from pydantic import BaseModel, Field\r\nfrom datetime import date\r\nfrom uuid import UUID\r\n\r\nclass ExpenseBase(BaseModel):\r\n    uuid: UUID = Field(description='Unique ID to be generated when creating an expense')\r\n    title: str = Field(..., max_length=100)\r\n    date: date\r\n    description: str = Field(..., max_length=500)\r\n    category: ExpenseCategory\r\n    amount: float = Field(..., gt=0)\r\n<\/code><\/pre>\n
Creating Result Answer Model<\/h3>\n
This model will structure the response from the AI agent, including the user’s tips and the list of expenses:<\/p>\n
from typing import List, Tuple, Union\r\n\r\nclass ResultAnswer(BaseModel):\r\n    answer_to_user: str = Field(description='The answer that should be returned to the user, the answer should be good direct and in a friendly tone.')\r\n    expense: Union[List[ExpenseBase] | None]\r\n    tips_to_user: Tuple[bool, Union[str, None]]\r\n<\/code><\/pre>\n
4. Integrating Pydantic-AI<\/h2>\n
Now that we\u2019ve defined our data models, we can create our AI agent<\/strong> using Pydantic-AI<\/strong>. This agent will be responsible for interpreting user queries, providing responses, and interacting with the Supabase<\/strong> database.<\/p>\n
from pydantic_ai import Agent, RunContext\r\nfrom pydantic_ai.models.openai import OpenAIModel\r\nfrom pydantic_ai.usage import UsageLimits\r\nfrom supabase import Client\r\nfrom uuid import UUID\r\n\r\n@dataclass\r\nclass Dependencies:\r\n    user_uuid: UUID # For this Demo we will not use it\r\n    supabase: Client | None\r\n\r\nexpense_agent = Agent(\r\n    model=OpenAIModel(\r\n        'deepseek-chat',  # Use your model name here\r\n        base_url='<https:\/\/api.deepseek.com\/v1>',\r\n        api_key='your_api_key',  # Replace with your actual API key\r\n    ),\r\n    deps_type=Dependencies,\r\n    result_type=ResultAnswer,\r\n    system_prompt=(\r\n        'You are an AI agent specialized in expense tracking, tasked with helping users manage their personal finances effectively. '\r\n        'Your functionalities should include recording expenses, generating reports, sending budget alerts, and providing insights based on spending patterns.'\r\n    ),\r\n    model_settings={'temperature': 0.0} # The higher the temperature the diverse the model answers can be\r\n)\r\n\r\n<\/code><\/pre>\n
5. Working with Supabase<\/h2>\n
<\/p>\n
Supabase is an open-source alternative to Firebase and provides a full set of backend services such as authentication, storage, and a powerful PostgreSQL database. For this project, we will primarily use Supabase’s PostgreSQL<\/strong> database to store, retrieve, and update user expenses.<\/p>\n
1. Setting Up Supabase Client<\/h3>\n
To interact with Supabase, you need to initialize the Supabase client<\/strong> in your app. This will allow us to make queries to the database, such as adding or retrieving expenses.<\/p>\n
from supabase import create_client, Client\r\n\r\nurl = '<https:\/\/xyz.supabase.co>'  # Replace with your Supabase URL\r\nkey = 'public-anon-key'  # Replace with your Supabase API key\r\n\r\nsupabase: Client = create_client(url, key)\r\n<\/code><\/pre>\n
2. Creating the Supabase Table for Expenses<\/h3>\n
Before adding or retrieving data from Supabase, ensure that you have created a table to store the expenses. Here’s an example SQL query to create the expenses<\/code> table:<\/p>\n
CREATE TABLE expenses (\r\n    uuid UUID PRIMARY KEY,\r\n    title TEXT NOT NULL,\r\n    date DATE NOT NULL,\r\n    description TEXT,\r\n    category TEXT NOT NULL,\r\n    amount FLOAT NOT NULL\r\n);\r\n<\/code><\/pre>\n
You can run this SQL query in the Supabase Dashboard<\/strong> under the “SQL Editor” tab.<\/p>\n
\n
6. Implementing Database Interaction Functions<\/h2>\n
Adding Expenses to Supabase<\/h3>\n
We\u2019ll implement a function that will insert expense data into the Supabase<\/strong> database:<\/p>\n
@expense_agent.tool\r\nasync def add_to_database(ctx: RunContext[Dependencies], expenses: List[ExpenseBase]) -> str:\r\n    \"\"\"\r\n    Add expenses to the database.\r\n    \"\"\"\r\n    try:\r\n        supabase: Client = ctx.deps.supabase_client\r\n        user_uuid: str = ctx.deps.user_uuid\r\n\r\n        rows_to_insert = []\r\n        for expense in expenses:\r\n            rows_to_insert.append({\r\n                \"user_uuid\": user_uuid,\r\n                \"title\": expense.title,\r\n                \"date\": expense.date.isoformat(),\r\n                \"description\": expense.description,\r\n                \"category\": expense.category.value,\r\n                \"amount\": expense.amount,\r\n            })\r\n\r\n        response = supabase.table(\"expenses\").insert(rows_to_insert).execute()\r\n        \r\n        return f\"Your Expenses have been saved. Inserted: {json.dumps(response.data, indent=2)}\"\r\n    except Exception as e:\r\n        return f\"Failed to add expenses to database. Error: {e}\"\r\n<\/code><\/pre>\n
This function converts the expense into a dictionary, ensuring the UUID is properly formatted, and then inserts the expense into the Supabase<\/strong> database.<\/p>\n
7. Retrieving Expenses from Supabase<\/h2>\n
To retrieve a list of expenses from the database, we implement a function that queries the expenses<\/code> table:<\/p>\n
@expense_agent.tool\r\nasync def retrive_from_database(ctx: RunContext[Dependencies]) -> str:\r\n    \"\"\"\r\n    Retrieve all expenses for the current user from the database.\r\n    \"\"\"\r\n    try:\r\n        supabase: Client = ctx.deps.supabase_client\r\n        user_uuid: str = ctx.deps.user_uuid\r\n\r\n        response = (\r\n            supabase\r\n            .table(\"expenses\")\r\n            .select(\"*\")\r\n            .eq(\"user_uuid\", user_uuid)\r\n            .order(\"created_at\", desc=True)  # or whichever order you prefer\r\n            .execute()\r\n        )\r\n\r\n        return json.dumps(response.data, indent=2)\r\n    except Exception as e:\r\n        return f\"Failed to add expenses to database. Error: {e}\"\r\n<\/code><\/pre>\n
This function queries all the records from the expenses<\/code> table and returns them as ExpenseBase<\/code> objects.<\/p>\n
8. Updating Expenses in Supabase<\/h2>\n
<\/p>\n
Finally, we\u2019ll add a function to update an existing expense in the database:<\/p>\n
@expense_agent.tool\r\nasync def update_from_database(ctx: RunContext[Dependencies], expense: ExpenseBase) -> str:\r\n    \"\"\"\r\n    Update an expense in the database using the expense.uuid as the primary key.\r\n    \"\"\"\r\n    try:\r\n        supabase: Client = ctx.deps.supabase_client\r\n\r\n        update_fields = {\r\n            \"title\": expense.title,\r\n            \"date\": expense.date.isoformat(),\r\n            \"description\": expense.description,\r\n            \"category\": expense.category.value,\r\n            \"amount\": expense.amount\r\n        }\r\n\r\n        # Use expense.uuid to locate the record in DB (assuming \"expense_id\" is the PK)\r\n        response = (\r\n            supabase\r\n            .table(\"expenses\")\r\n            .update(update_fields)\r\n            .eq(\"expense_id\", str(expense.uuid))\r\n            .execute()\r\n        )\r\n\r\n        return f\"Expense {expense.uuid} updated successfully. Result: {json.dumps(response.data, indent=2)}\"\r\n\r\n    except Exception as e:\r\n        return f\"Failed to add expenses to database. Error: {e}\"\r\n\r\n<\/code><\/pre>\n
Other tools to help the model generate expenses<\/h3>\n
@expense_agent.tool\r\nasync def todays_date(ctx: RunContext[Dependencies]) -> str:\r\n    return str(date.today())\r\n\r\n@expense_agent.tool\r\nasync def generate_uuid(ctx: RunContext[Dependencies]) -> str:\r\n    return str(uuid.uuid4())\r\n<\/code><\/pre>\n
Testing the Agent response<\/h3>\n
from IPython.display import Markdown, display\r\n\r\nr = expense_agent.run_sync(\r\n    'I did buy 10 candies each one of them with 15dh, 2 bottles of water for 5dh each, and a sandwich for 20dh.',\r\n    deps=Dependencies(\r\n        user_uuid='cdb64645-e1e4-4686-af86-de8f581b8037',\r\n        supabase_client=None\r\n    ),\r\n    usage_limits=UsageLimits(request_limit=5),\r\n)\r\nprint(f\"Answer for User:\\\\n>>{r.data.answer_to_user}\")\r\nprint(f\"Tips for User:\\\\n>>{r.data.tips_to_user[1] if r.data.tips_to_user[0] else 'No tips'}\")\r\nprint(f\"Expense Recorded:\\\\n>>{r.data.expense}\")\r\n<\/code><\/pre>\n
Output sample<\/h3>\n
Answer for User:<\/strong><\/p>\n
Your expenses have been recorded successfully. Here’s a summary of your recent expenses:<\/p>\n