DEV Community: Anurag Kanojiya

How to Dynamically Change App Language in Jetpack Compose (Modern Android Guide) 🚀🌏

Anurag Kanojiya — Sat, 14 Mar 2026 22:43:27 +0000

Many apps today let users choose their preferred language directly inside the app — not just rely on the device language.

For example:

Someone learning a language may want the app in Spanish 🇪🇸
Or you might simply want to test translations during development

Good news: modern Android provides a clean official way to change app language dynamically using AppCompat 1.6+.

Let's implement it step by step. 👇

🚀 Step 1 — Add AppCompat

First, you need the AppCompat library because the locale API lives there.

Add this dependency:

implementation("androidx.appcompat:appcompat:1.6.1")

If you're using Version Catalogs it may look like:

implementation(libs.androidx.appcompat)

🧩 Step 2 — Use `AppCompatActivity`

To enable the locale API, your MainActivity must extend AppCompatActivity.

Replace this:

class MainActivity : ComponentActivity()

with this:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    }

}

That's it — now your app can use AppCompat locale management.

🌐 Step 3 — Add Language Resources

Now we define localized strings.

Inside the res folder, create resource directories using language qualifiers like:

values/strings.xml
values-hi/strings.xml
values-bn/strings.xml
values-ta/strings.xml

Example:

English

<string name="hello">Hello</string>

Hindi

<string name="hello">hola</string>

Android automatically loads the correct translation depending on the selected locale.

🧠 Step 4 — Create a Language Manager

Instead of repeating locale logic everywhere, we create a small LanguageManager helper.

object LanguageManager {

    fun setLanguage(code: String) {
        val locale = LocaleListCompat.forLanguageTags(code)
        AppCompatDelegate.setApplicationLocales(locale)
    }

    fun resetToSystem() {
        AppCompatDelegate.setApplicationLocales(
            LocaleListCompat.getEmptyLocaleList()
        )
    }
}

What this does

setApplicationLocales() tells Android:

"Hey, switch the entire app to this locale."

Android then refreshes the UI automatically.

Super clean ✨

📦 Step 5 — Create a Language Model

Next, let's define a simple data model.

data class AppLanguage(
    val code: String,
    val label: String
)

Now define the languages supported by your app:

val languages = listOf(
    AppLanguage("en", "English"),
    AppLanguage("hi", "Hindi"),
    AppLanguage("as", "Assamese"),
    AppLanguage("bn", "Bengali"),
    AppLanguage("gu", "Gujarati"),
    AppLanguage("kn", "Kannada"),
    AppLanguage("ml", "Malayalam"),
    AppLanguage("mr", "Marathi"),
    AppLanguage("or", "Odia"),
    AppLanguage("pa", "Punjabi"),
    AppLanguage("ta", "Tamil"),
    AppLanguage("te", "Telugu"),
    AppLanguage("ur", "Urdu")
)

These language codes match the resource folder qualifiers (values-hi, values-es, etc.).

🎯 Step 6 — Change Language from UI

Now the fun part.

You can change the language from onboarding, settings, or anywhere in your app.

Example:

LanguageManager.setLanguage("hi")

Or if you're showing a list of languages:

languages.forEach { language ->
    LanguageManager.setLanguage(language.code)
}

Example button:

Button(
    onClick = {
        LanguageManager.setLanguage("hi")
    }
) {
    Text("Switch to Hindi")
}

Once triggered, Android will:

1️⃣ Change the locale
2️⃣ Reload resources
3️⃣ Update UI automatically

No manual activity restart required 🎉

🔄 Reset Language to System Default

If the user wants the app to follow the device language, just call:

LanguageManager.resetToSystem()

Android will switch back to the system locale.

⚡ Why This Approach Is Great

Using AppCompatDelegate.setApplicationLocales() gives you:

✅ Official AndroidX solution
✅ Works with Jetpack Compose + Views
✅ No deprecated locale hacks
✅ Automatic UI refresh
✅ Clean and maintainable code

🎉 Final Result

Your app now supports:

🌍 Dynamic language switching
⚡ Instant UI updates
📱 System language fallback
🧩 Clean architecture

All with just a few lines of code.

💡 Pro Tip

If you want the language to persist across app restarts, store the selected language in:

DataStore

Then apply it when the app launches.

That's it!

Your Android app is now ready for global users 🌎

🧑‍💻 Author

Anurag Kanojiya — Android app Developer | Kotlin | KMP | Java | Spring Boot

• Twitter • LinkedIn • GitHub

🎬 Semantic Search for Movies & Series with MindsDB and FastAPI

Anurag Kanojiya — Sun, 29 Jun 2025 16:34:19 +0000

In this post, I’ll walk you through the FastAPI-based backend of BingeMate and how it integrates with MindsDB to enable semantic search, metadata filtering, and even conversational agent responses using a SQL-powered interface.

🧠 What Is BingeMate?

BingeMate is a semantic search and recommendation engine that helps users find the perfect movie or series using natural language queries like:

“Top-rated Netflix thrillers after 2020”
“Feel-good anime with high IMDb ratings”
“Is ‘Dark’ similar to ‘Stranger Things’?”

The backend is powered by FastAPI and connects to a MindsDB knowledge base, which stores semantically indexed chunks of content using LLMs and vectors.

anuragkanojiya1 / BingeMate-Backend

This project is a FastAPI backend for BingeMate

⚙️ BingeMate-Backend

This project is a FastAPI backend for BingeMate querying a MindsDB Knowledge Base powered by Ollama LLMs and embedding models. It integrates:

🌐 FastAPI backend
🧠 MindsDB KB, Jobs, Agent
🦙 Ollama (Mistral + Granite embedding)
🐳 Docker for environment management

Demo Video	Blog Post

📦 Requirements

Before getting started, make sure you have installed:

Docker Desktop
Ollama
Python 3.8+

📁 Project Structure

project-root

│── mindsdb_client.py
├── main.py
├── requirements.txt
├── bingewatch.csv
└── README.md

🧪 Step-by-Step Setup

1️⃣ Clone this repo

git clone https://github.com/your-username/BingeMate-Backend.git
cd BingeMate-Backend

2️⃣ Install Python dependencies

pip install -r requirements.txt

3️⃣ Run MindsDB in Docker

docker run --name mindsdb_container -e MINDSDB_APIS=http,mysql -p 47334:47334 -p 47335:47335 mindsdb/mindsdb

4️⃣ Start Ollama and download models

Ollama must be running in the background.

ollama run granite-embedding
ollama run mistral

🤖 Configure MindsDB

Once MindsDB and Ollama are running, execute the following commands to set up:

📚 Create a

…

View on GitHub

⚙️ Backend Tech Stack

FastAPI: Lightweight, high-performance Python web framework for building APIs.
MindsDB SDK: Python client to query MindsDB knowledge bases and agents
Pandas: For formatting query results
Uvicorn: ASGI server for FastAPI
JSON-based filtering: For flexible metadata queries

📁 Project Structure

📦 bingemate-backend/
├── main.py                  # FastAPI app with routes
├── bingewatch.csv           # CSV file that contains movie/series data
├── mindsdb_client.py        # MindsDB SDK helper functions
├── requirements.txt         # Dependencies

🧪 API Endpoints

`/query` — Search Knowledge Base

@app.get("/query")
def search_kb(
    request: Request,
    q: str = Query(..., description="Search query, e.g., 'best series'"),
    min_relevance: float = Query(0.25, description="Minimum relevance threshold"),
):
    query_params = dict(request.query_params)
    query_params.pop("q", None)
    query_params.pop("min_relevance", None)

    results = query_knowledge_base(
        search_query=q, 
        min_relevance=min_relevance, 
        metadata=query_params
    )
    return {"count": len(results), "results": results}

🔎 Accepts a natural language query like "popular kdrama in 2023"
📊 Supports dynamic metadata filters like ?type=Series&genre=Drama
🔁 Filters results by minimum relevance score

`/agent` — Ask a Question via Agent

@app.get("/agent")
def create_agent(
    query: str = Query(..., description="Question to ask the agent"),
    description: Optional[str] = Query(None, description="Description of the agent")
):
    result = query_agent(query=query)
    return {"result": result}

This endpoint interacts with a MindsDB agent that answers natural language questions based on pre-trained or fine-tuned SQL logic.

`/api/projects/mindsdb/jobs` — Simulated Job Endpoint

@app.post("/api/projects/mindsdb/jobs")
def create_job(
    project: str,
    job_name: str,
    query: str
):
    return {
        "message": f"Job '{job_name}' created in project '{project}' with query: {query}"
    }

✏️ Note : The MindsDB Job endpoint is used to schedule specific timepoints at which an SQL query will be executed.

🔧 mindsdb_client.py — Query Logic

This module handles communication with MindsDB via SQL.

Search the Knowledge Base

def query_knowledge_base(search_query: str, min_relevance: float = 0.25, metadata: dict = None):
    conditions = [f'content = "{search_query}"', f"relevance >= {min_relevance}"]
    if metadata:
        for key, value in metadata.items():
            conditions.append(f"{key} = '{value}'")
    sql = f"SELECT * FROM my_bingekb WHERE {' AND '.join(conditions)};"
    query = server.query(sql)
    df = query.fetch()
    ...

✅ Uses SQL to query my_bingekb table
🧠 Automatically filters results using relevance and metadata (e.g., type, genre)
🔄 Converts results to a JSON-friendly format

Ask a Question to an Agent

def query_agent(query: str):
    sql = f"""
    SELECT answer FROM my_agent WHERE question = "{query}";
    """
    df = server.query(sql).fetch()
    return df

This enables direct Q&A via a SQL-like agent interface. You can map semantic questions to custom-trained answers.

🧪 requirements.txt

fastapi
uvicorn
mindsdb_sdk
pandas

🚀 To run:

pip install -r requirements.txt
uvicorn main:app --reload

🌐 Example Usage

GET /query?q=best%20series%20on%20netflix&genre=Drama&type=Series

GET /agent?query=Is%20Breaking%20Bad%20better%20than%20Ozark

💡 Final Thoughts

FastAPI + MindsDB gives you a supercharged backend for semantic search and conversational interfaces. Whether you’re building a movie recommender, travel planner, or knowledge assistant—this stack is lightweight, extensible, and LLM-ready.

Now go and check out the implementation of this backend -- BingeMate!

anuragkanojiya1 / BingeMate

🎬 BingeMate – Your AI-Powered Movie & Series Finder

🎬 BingeMate – Your AI-Powered Movie & Series Finder 🎙️📺

BingeMate is a Jetpack Compose Android application that helps users discover movies and series using Voice input and Semantic search powered by MindsDB Knowledge Base and Ollama LLMs.

It combines natural language queries with structured filters like genre, type, year, and IMDb rating to return personalized results from Mindsdb Knowledge base App's backend link is required to get movie/series data for Semantic/agent search - BingeMate-Backend

Demo Video	Blog Post

🚀 Features

🎤 Voice-Powered Search

Uses Google Speech Services for hands-free querying.

🔍 Semantic Movie/Series Search

Queries are processed through MindsDB's Knowledge Base, which semantically matches user intent to documents (movie/series data) in the database.

📚 Metadata Filters

Users can refine results using:
- 🎭 genre (e.g., action, comedy)
- 🎞️ type (movie/series)
- 📅 year (e.g., 2023)
- ⭐ IMDb rating (e.g., >8.0)

🤖 Conversational Agent

A built-in agent powered by Ollama…

View on GitHub

🔗 Connect with me

𝕏 Twitter | 👨🏻‍💻 GitHub | ✉ Gmail | ▶ YouTube | 🇮🇳 LinkedIn

How to use LangGraph within a FastAPI Backend 🚀

Anurag Kanojiya — Tue, 01 Apr 2025 14:23:56 +0000

In this tutorial, I’ll walk you through how to build a backend to generate AI-crafted emails using LangGraph for structured workflows and FastAPI for API endpoints.

📌 Prerequisites

1️⃣ Install Dependencies

Create a requirements.txt file and add these dependencies:

fastapi
uvicorn
pydantic
python-dotenv
google-generativeai
langgraph
langchain

Now, install them using the below command in terminal inside your project folder:

pip install -r requirements.txt

📌 Setting Up the Backend

2️⃣ Create `backend.py` and Import Required Modules

from fastapi import FastAPI
from pydantic import BaseModel
import os
import google.generativeai as genai
import langgraph
from langgraph.graph import StateGraph
from dotenv import load_dotenv

What Do These Modules Do?

FastAPI → API framework
Pydantic → Request validation
os → Load environment variables
google-generativeai → Gemini AI for email generation
langgraph → Manages AI workflows
dotenv → Loads API keys from a .env file

3️⃣ Load Environment Variables & Initialize FastAPI

load_dotenv()
app = FastAPI()

GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
genai.configure(api_key=GEMINI_API_KEY)

✅ What do these do?

.env helps keep API keys secure instead of hardcoding them.
FastAPI() initializes the backend application.

📌 Defining the API

4️⃣ Request Model (Pydantic Validation)

class EmailRequest(BaseModel):
    tone: str      
    ai_model: str  
    language: str  
    context: str

This ensures the API gets structured input:

tone → Email tone (e.g., formal, friendly).
ai_model → Which AI to use (gemini or mistral).
language → Language of the email (e.g., English, French).
context → The purpose/content of the email.

5️⃣ AI Email Generation Function (Gemini)

def generate_email_gemini(language: str, tone: str, context: str):
    model = genai.GenerativeModel("gemini-2.0-flash")

    prompt = f"""
    Generate an email in {language} with a {tone} tone. Context: {context}
    Return the response in this format:
    Subject: //subject
    Body: //body
    """

    response = model.generate_content(prompt)
    response_text = response.text.strip()

    subject, body = response_text.split("Body:", 1) if "Body:" in response_text else ("No Subject", response_text)
    subject = subject.replace("Subject:", "").strip()
    body = body.strip()

    return {"subject": subject, "body": body}

✅ How It Works?

Calls Gemini AI using "gemini-2.0-flash".
Constructs a prompt for email generation.
Parses the AI response and extracts subject & body.

6️⃣ Structuring the Workflow with LangGraph

def generate_email_graph(ai_model: str, tone: str, language: str, context: str):
    def email_generation_fn(state):
        if ai_model == "gemini":
            email = generate_email_gemini(language, tone, context)
        else:
            email = "Invalid AI model selected!"
        return {"email": email}

    graph = StateGraph(dict)  
    graph.add_node("generate_email", email_generation_fn)
    graph.set_entry_point("generate_email")

    return graph.compile()

✅ Why Use LangGraph?

Creates structured AI workflows.
Makes it easy to expand functionalities (e.g., adding post-processing).
Can be extended with multiple AI models (Mistral, GPT, etc.).

📌 FastAPI Routes

7️⃣ Root Endpoint

@app.get("/")
def read_root():
    return {"message": "Hello, AutoComposeBackend is live!"}

This simply confirms the server is running.

8️⃣ AI Email Generation API Endpoint

@app.post("/generate_email")
async def generate_email(request: EmailRequest):
    """Generate an AI-crafted email using Gemini."""
    graph = generate_email_graph(request.ai_model, request.tone, request.language, request.context)
    response = graph.invoke({})
    return response

✅ How It Works?

Receives input via POST request (EmailRequest).
Calls generate_email_graph to create a workflow.
Executes the AI model and returns the email response.

📌 Running the Server

Save backend.py and run on terminal:

uvicorn backend:app --host 0.0.0.0 --port 8080

Now, visit:

➡ http://0.0.0.0:8080/docs to test the API using FastAPI’s built-in Swagger UI or postman.

🚀 Deploying FastAPI on Railway.app

Now that our FastAPI backend is ready, let's deploy it on Railway.app, a cloud platform for hosting backend applications effortlessly.

1️⃣ Create a Railway Account & New Project

Go to Railway.app and sign up.
Click on "New Project" → "Deploy from GitHub".
Connect your GitHub repository containing the FastAPI backend.

2️⃣ Add a `Procfile` for Deployment

Railway uses a Procfile to define how your app runs. Create a Procfile in your project root:

web: uvicorn backend:app --host 0.0.0.0 --port $PORT

✅ Why?

uvicorn backend:app → Starts the FastAPI server.
--host 0.0.0.0 → Allows Railway to bind it to a public address.
--port $PORT → Uses the Railway-assigned port dynamically.

3️⃣ Add Environment Variables in Railway

Since we use API keys, they must be stored securely:

In your Railway Project Dashboard, go to Settings → Variables.
Add environment variables:
- GEMINI_API_KEY = your_api_key_here

4️⃣ Deploy the App on Railway

Click on Deploy.
Wait for the deployment to complete. Once done, you'll get a public URL (e.g., https://your-app.up.railway.app).

Note: If you do not get a domain automatically then create a public domain manually from the project's networking section.

5️⃣ Test Your Deployed API

Open:

➡ https://your-app.up.railway.app/docs

Here, you can test API endpoints using FastAPI's built-in Swagger UI or on postman.

🎯 Done! Your FastAPI Backend is Live! 🚀

You now have a FastAPI backend running on Railway.app with LangGraph-powered AI email generation.💡

Next tutorial would be about me integrating this FastAPI-LangGraph powered backend with a Jetpack Compose frontend! 🚀

🚀A Developer’s Guide to Integrating Daytona with Android Projects ✨

Anurag Kanojiya — Fri, 27 Dec 2024 12:18:30 +0000

Hey devs! 👋

I recently submitted an Android-Blockchain app for transparent donation tracking for Daytona's sample project. It was an exciting experience, and I wanted to share how Daytona made everything easier. 🚀

What’s Daytona? 🤔

Daytona is a tool that simplifies setting up and managing your dev environment. It makes working with different projects much smoother, especially if you’re trying to simplify workspace management. I used it for my Android blockchain project for donation tracking.

My Android project - HopeChain, uses Jetpack Compose for building the UI and Solana blockchain for tracking donations. With Daytona, setting up the whole environment was a breeze, and I’m here to walk you through it! 🌟

🛠️ Prerequisites

Before we dive in, here are a few things you’ll need to get started:

Android SDK 🔧
Docker 🐋
JetBrains Gateway 🧑‍💻

These tools will help you set up Daytona and configure everything for a seamless experience.

🚀 Getting Started

1. Install Daytona

First off, you need Daytona on your system. Follow this Daytona Installation Guide to set it up.

2. Install Docker

You’ll also need Docker to isolate and configure the entire setup. Docker makes sure everything runs in its own container, keeping things clean and efficient. 🐳

3. Set Up JetBrains Gateway

Once Docker is running, you’ll need JetBrains Gateway to connect your IDE remotely. It’s great for seamless development across different environments. Check out the installation guide here.

4. Create the Workspace

Next, you’ll create the workspace using Daytona:

daytona create https://github.com/daytonaio/sample-android-blockchain

Daytona will take care of setting up everything for you, so you can get straight to development. 😎

5. Open in IntelliJ IDEA

Daytona automatically opens the project in IntelliJ IDEA Ultimate with all the SDKs and tools pre-configured. If for some reason it doesn’t, you can always open it manually. 🖥️

daytona code

6. Install the Android Plugin

For IntelliJ to recognize Android projects, you’ll need to install the Android plugin. Here’s a quick screenshot of the setup process:

Follow the steps, accept the license agreement, and proceed. Once done, you’ll see the Run and Devices section in the top menu.

7. Build the APK

Now, it’s time to generate your APK. Go to the Build section and hit Generate APK. After it’s done, you can find your APK path and copy it to your local system using Docker commands.

docker cp <CONTAINER_ID>:/home/daytona/sample-android-blockchain/app/build/outputs/apk/debug/app-debug.apk /path/to/destination/on/host

8. Run on Your Device

Once you have the APK, you can install it on your Android device using ADB which is found in the Platform tools in Android sdk downloaded earlier:

adb install path/to/your-app.apk

And voilà! Your app is now running on your device. 🎉

Final Product 🎁

Here’s a glimpse of the HopeChain app once it’s up and running:

🧑‍💻 Project Structure

Here’s a quick breakdown of the project:

Jetpack Compose UI: Modern UI built with Jetpack Compose.
Blockchain Integration: Using Solana to securely track donations.
Auto Builder Support: Daytona can build a Project using the default base image.

Why Daytona Made It All Easy 🧑‍💻

Daytona saved me a ton of time by automating environment setup and project configuration. No more struggling with environment variables, SDK installations, or misconfigured dependencies. Everything worked out of the box. 🙌

Currently Daytona only provides these JetBrains IDEs :

CLion
GoLand
IntelliJ IDEA Ultimate
PhpStorm
PyCharm Professional
Rider
RubyMine
WebStorm
Fleet

In future Daytona would also include Android Studio, which is the official IDE for Android development to make our development far more easy.✨

Happy coding! 🚀

My Journey with Anthropic API and Mistral AI🚀🤖

Anurag Kanojiya — Tue, 17 Sep 2024 18:55:12 +0000

Hello Developers🧑‍💻, I have made MyHealth Passport, a project for Quira Quest 16 which is an Android App integrated with Gemini API, Cosmocloud Object Storage, Cloud Firestore Database, Anthropic API and Mistral AI. I've added two awesome tools for the Quira quest in my Jetpack Compose Android app: a Personal Therapist Chatbot using Anthropic AI and a Personalized Diet & Exercise Planning AI Agent using Mistral. Here is a quick look at how these APIs made my development process easy.

1. Personal Therapist Chatbot with Anthropic API 🧠💬

I used the Anthropic API to create a Personal Therapist chatbot. It interacts like a professional therapist with the user, it offers thoughtful and empathetic responses. The integration was smooth, thanks to the user-friendly endpoints and clear documentation provided by Anthropic.

What I loved: How easily it integrated into my Jetpack Compose Android app. The responses are super fast, and the interactions feel very natural and supportive.

2. Personalized Diet & Exercise Planner with Mistral AI 🍎🏋️‍♂️

For personalized diet and exercise recommendations, I used Mistral AI to build an agent that makes plan based on users' medical data. By simply entering a medical ID, users receive customized diet and exercise plans. The Mistral Agent Builder made it super easy to set up, and the API documentation was really helpful.

What I loved: How quickly I could build customized agents with very low effort. The Mistral API’s endpoint for agents was excellent, allowing me to built it in no time.

Challenges and Solutions 🔧💡

One major challenge was aligning the APIs with the MVVM architecture, which was tricky at first. However, the rich documentation and accessible features made it manageable. The Mistral endpoint for agents was very impressive and quick, and Anthropic’s fast response time made the chatbot interactions fast.

Final Thoughts 🌟

Anthropic API and Mistral AI have truly transformed my app development experience. Their straight forward features and ease of use made integration very smooth. If you’re looking to enhance your projects with advanced AI capabilities, these tools are definitely worth checking out!

#AnthropicAPI #MistralAI #JetpackCompose #AndroidDevelopment #Quira #Quine #DevCommunity

DEV Community: Anurag Kanojiya

How to Dynamically Change App Language in Jetpack Compose (Modern Android Guide) 🚀🌏

🚀 Step 1 — Add AppCompat

🧩 Step 2 — Use AppCompatActivity

🌐 Step 3 — Add Language Resources

🧠 Step 4 — Create a Language Manager

What this does

📦 Step 5 — Create a Language Model

🎯 Step 6 — Change Language from UI

🔄 Reset Language to System Default

⚡ Why This Approach Is Great

🎉 Final Result

💡 Pro Tip

🧑‍💻 Author

🎬 Semantic Search for Movies & Series with MindsDB and FastAPI

🧠 What Is BingeMate?

anuragkanojiya1 / BingeMate-Backend

This project is a FastAPI backend for BingeMate

⚙️ BingeMate-Backend

📦 Requirements

📁 Project Structure

🧪 Step-by-Step Setup

1️⃣ Clone this repo

2️⃣ Install Python dependencies

3️⃣ Run MindsDB in Docker

4️⃣ Start Ollama and download models

🤖 Configure MindsDB

📚 Create a

⚙️ Backend Tech Stack

📁 Project Structure

🧪 API Endpoints

/query — Search Knowledge Base

/agent — Ask a Question via Agent

/api/projects/mindsdb/jobs — Simulated Job Endpoint

🔧 mindsdb_client.py — Query Logic

Search the Knowledge Base

Ask a Question to an Agent

🧪 requirements.txt

🚀 To run:

🌐 Example Usage

💡 Final Thoughts

anuragkanojiya1 / BingeMate

🎬 BingeMate – Your AI-Powered Movie & Series Finder

🎬 BingeMate – Your AI-Powered Movie & Series Finder 🎙️📺

🚀 Features

🎤 Voice-Powered Search

🔍 Semantic Movie/Series Search

📚 Metadata Filters

🤖 Conversational Agent

How to use LangGraph within a FastAPI Backend 🚀

📌 Prerequisites

1️⃣ Install Dependencies

📌 Setting Up the Backend

2️⃣ Create backend.py and Import Required Modules

What Do These Modules Do?

3️⃣ Load Environment Variables & Initialize FastAPI

📌 Defining the API

4️⃣ Request Model (Pydantic Validation)

5️⃣ AI Email Generation Function (Gemini)

6️⃣ Structuring the Workflow with LangGraph

📌 FastAPI Routes

7️⃣ Root Endpoint

8️⃣ AI Email Generation API Endpoint

📌 Running the Server

🚀 Deploying FastAPI on Railway.app

1️⃣ Create a Railway Account & New Project

2️⃣ Add a Procfile for Deployment

3️⃣ Add Environment Variables in Railway

4️⃣ Deploy the App on Railway

5️⃣ Test Your Deployed API

🎯 Done! Your FastAPI Backend is Live! 🚀

🚀A Developer’s Guide to Integrating Daytona with Android Projects ✨

What’s Daytona? 🤔

🛠️ Prerequisites

🚀 Getting Started

1. Install Daytona

2. Install Docker

3. Set Up JetBrains Gateway

4. Create the Workspace

5. Open in IntelliJ IDEA

🧩 Step 2 — Use `AppCompatActivity`

`/query` — Search Knowledge Base

`/agent` — Ask a Question via Agent

`/api/projects/mindsdb/jobs` — Simulated Job Endpoint

2️⃣ Create `backend.py` and Import Required Modules

2️⃣ Add a `Procfile` for Deployment