TL;DR
We built an AI app with DeepSeek and GPT-4o. See how we did it:
Introduction
In early 2025, DeepSeek R1 gained widespread recognition for its cost-effectiveness, strong logical reasoning, and open-source nature. Its exceptional coding and language-processing capabilities made it popular among AI enthusiasts. However, its potential extends beyond simple chatbot applications—it can serve as the foundation for custom AI assistants and customer service bots. For startups seeking an affordable alternative to GPT-based APIs, DeepSeek presents a compelling choice.
Yet, DeepSeek has limitations—it lacks the essential features of an AI agent. Because of this, DeepSeek alone isn't enough to build a fully functional AI agent (as of March 2025). However, with Momen’s integrated AI agent builder and BYOM (Bring Your Own Model) support, we integrated DeepSeek into an agentic workflow without writing any code. In this guide, we’ll demonstrate how to build a diet assistant app called "Angry Dietitian", combining DeepSeek’s capabilities in reasoning and text generation, with GPT-4o for image processing.
Here's a preview of the DeepSeek app we build with Momen :
Why DeepSeek for AI App Development?
- Cost effectiveness: DeepSeek R1 offers a significantly cheaper alternative to other AI models:
OpenAI GPT-4o: $5.50 per 1M tokens (weighted cost, assuming a 1.5 input/output ratio).
DeepSeek R1: $1.21 per 1M tokens—78% cheaper than GPT-4o.
Advanced reasoning capabilities: DeepSeek R1 is optimized for complex reasoning tasks, making it suitable for AI applications requiring logical processing and in-depth analysis.
Efficient Resource Utilization: Unlike some larger models, DeepSeek R1 can run efficiently on consumer-grade hardware, making it more accessible for AI developers and startups.
What DeepSeek Can’t Do (And How to Work Around It)
While DeepSeek excels in reasoning and cost efficiency, it lacks native support for (as of March 2025):
Multimodal inputs (e.g., image recognition).
Native JSON structured output.
Tool invocation for dynamic API calls.
To overcome these limitations, we use Momen’s AI agent builder to integrate multiple AI models into a single application.
Why Momen? The Power of BYOM (Bring Your Own Model)
Momen enables AI agent orchestration—allowing users to:
- Integrate their preferred AI models (e.g., DeepSeek, GPT-4o, GPT-4o mini).
GPT-4o and GPT-4o mini are built-in in Momen, but you can also
.Generate structured JSON outputs (ideal for frontend display and inter-agent collaboration).
Deploy your AI app with one click, no-code needed.
With Momen’s new BYOM feature, you can configure your AI agent using your own deployed DeepSeek model—ensuring greater control, reliability, and reduced downtime.
Core Functions
Main Features
- AI capabilities:
DeepSeek-powered analysis: The app leverages DeepSeek’s text generation and reasoning abilities to provide personalized dietary suggestions.
Multi-agent collaboration: GPT-4o handles image recognition, while DeepSeek provides text-based insights.
AI message storage: Momen has default tables in the database that log each conversation, ensuring debugging and auditing.
- Customizable UI: Build the UI tailored to your needs.
Step-by-Step: Build the AI diet app
Data
This app requires 5 tables, all of which are default tables that are automatically created when you set up a new project and configure the AI. This means no additional tables need to be manually created.
- Account table: Stores user information. We need to add some fields to store their body data, like height, weight, date of birth, fitness goals etc.
The following four tables are automatically generated when configuring the AI:
Message Content: Stores the content of each message from the AI. In this template, it records the reasoning and output of DeepSeek.
Conversation: Tracks the status of each conversation, including the user, the AI model, input data, conversation status, and any error messages.
Tool Usage: Typically records which tools the AI has invoked, but for this case, this table is not used.
Message: Tracks the token usage for each message in a conversation. You can view how many tokens were used by the user, the AI, or the system.
AI Configuration
Configuring GPT-4o (Image Processing)
Input: User-uploaded food images.
Prompt Setup: Configured as a "food analyzer" to extract food type and estimated weight.
Output Format: JSON structured output for better agent collaboration.
Once it's done. We can debug on the right side to see if it works.
Integrating DeepSeek (Diet Analysis)
Note: ⚠️ You must deploy your own DeepSeek model through a cloud provider (e.g., Azure, AWS) when before configuring DeepSeek.
Deploy your model: Head to the cloud providers, for example, Azure. Sign in, choose the AI foundry service. Search and deploy your own model. You'll find the endpoint and key after you deploy.
Set up in Momen
Navigate to "Add Model" in Momen.
Copy the API endpoint and key from the cloud provider.
Paste the credentials into Momen’s model integration page.
Select the model when configuring the agent.
Input: User body data (from the Account table) and food details (from GPT-4o).
Output: Personalized diet suggestions based on streaming output.
Here's an example of the prompt:
UI Design & Data Binding
Once the AI configuration is complete, we move on to UI building. The app consists of three main pages:
Sign Up/Sign In Page – User authentication
Form Page – Collects user body data
Roaster Page – The main interaction hub where AI agents analyze the user's food
Sign up/ Sign in
This page allows users to create an account or log in.
- Components:
A title at the top
A tab view with two options: "Sign Up" and "Sign In"
Two labels and input boxes under each tab (for email and password)
A button to handle authentication
- Functionality:
The button is linked to user sign-up and login actions
Once authenticated, the user is redirected to the Form Page
Form Page
This page collects key body metrics required for dietary recommendations.
- Components:
Input boxes for height, weight, date of birth, and fitness goals
Labels corresponding to each field
A button to submit the data
- Functionality:
The button updates the Account Table, storing the user’s body data
After submission, the user is taken to the Roaster Page
Roaster
This is the core interface where AI agents analyze food and provide feedback.
The Roaster Page has a central circular UI design, consisting of:
A large circle in the center – Displays AI results and changes based on interaction.
Multiple smaller circles surrounding it – Each displays a key user body metric.
Small circles - Displaying user body metric
Surrounding the main interaction area are small circles, each showing an essential body metric. These values are dynamically pulled from the Account Table and displayed in real-time. If the user updates their body data, the circles automatically refresh.
Large center circle - AI interaction area
This is the main interaction zone, where the AI agents analyze food images and provide suggestions. It's a conditional view with four cases: before upload, uploaded, roasting, roasted. The conditions will be the page state.
- Before upload:
- Components:
Image Picker: Allows users to upload a food image.
Prompt Text: “Show me your food!”
- Action: Once an image is uploaded, the page state is updated (state = uploaded).
- Uploaded:
- Components:
Displays the selected image in the circle.
A "Roast" button appears, allowing users to initiate AI analysis.
- Action: Clicking "Roast" triggers:
Page state updates to "roasting" (state = roasting).
"The Eye" (GPT-4o) is called, processing the image into structured text (JSON).
If the image is invalid (not food), an error message is displayed.
- Roasting:
Components: An animated loading effect to indicate AI processing.
Action:
GPT-4o extracts structured data (food type & estimated weight).
If the image does not contain food, a toast notification appears:
If successful:
Page state updates to "roasted" (state = roasted).
The DeepSeek agent ("The Roaster") is triggered, processing the food data into dietary advice.
The reasoning process is stored in the reason variable.
The final AI suggestion is stored in the answer variable.
- Roasted:
- Components:
Dietary recommendations displayed inside the central circle.
A "Why?" button appears, revealing the AI reasoning process in a modal.
- Actions:
The dietary advice is bound to the answer variable and displayed.
Clicking “Why?” opens a modal showing the reasoning stored in the reason variable.
Preview & Publish
Once everything is set up. Click "Mirror" to check UI and interactions. Finally, click "publish" to deploy your project.
Cost & Time Estimate
Cost
Since this project involves two AI agents working together, you'll need Momen’s Basic plan or higher, starting at $33 per month. The Bring Your Own Model (BYOM) feature is available for free until May 30th 2025, allowing you to integrate your own deployed DeepSeek model at no additional cost. If you're building an AI app exclusively with DeepSeek, you can use Momen for free—no subscription required.
However, keep in mind that deploying your own model requires a cloud provider, such as Azure, and any associated costs will be covered by you.
Time
The entire build process, from setup to deployment, takes approximately 1.5 hours.
Template
We've made this project into a template. You can explore and customize it here: https://o2w08d4qv40yk.villa.momen.app
The usage guide: https://docs.momen.app/template/angry-dietitian
Conclusion
This is just the starting point. You can expand your AI app by adding features like payment integration to monetize it. DeepSeek isn’t just for text generation—it can power AI apps tailored to your needs.
If you're ready to build, bring your model to Momen and start creating—no coding required!
Top comments (0)