DEV Community: Mohit Bisht

FoodFacts API - AI-Powered Nutrition & Recipe REST API

Mohit Bisht — Mon, 15 Dec 2025 06:36:41 +0000

This is a submission for the Xano AI-Powered Backend Challenge: Production-Ready Public API

What I Built

FoodFacts API is a production-ready public REST API that provides nutrition, meal, and food data powered by AI. It returns structured results that apps can rely on.

Developers can use the API to analyze food, estimate calories and macronutrients, generate diet plans, and create recipes from natural language input. The API is stateless and built for real-world use in fitness apps, diet planners, recipe platforms, and health dashboards.

FoodFacts API combines AI reasoning with strict JSON schemas to ensure responses stay predictable and easy to parse.

Architecture Diagram

What Data Services Does FoodFacts API Provide?

FoodFacts API supports these services:

Food nutrition data such as calories, protein, carbs, and fats
Meal-level macro estimates from free-text descriptions
Ingredient-based nutrition analysis
Goal-based diet plan generation
Recipe generation from available ingredients

All responses return clean, structured JSON designed for direct use in web and mobile apps.

Key Features

Food Nutrition Search
Developers can search nutrition data for common foods. This supports calorie tracking and food databases without extra setup.

Meal and Ingredient Analysis
The API estimates nutrition from:

A list of ingredients
A natural language meal description

This removes the need to maintain large food databases.

AI-Generated Diet Plans
Based on user goals such as weight loss or muscle gain, the API generates multi-day plans that include:

Daily meals
Estimated calories
Grocery lists
Health tips

Recipe Generation
Given a list of ingredients, the API returns:

Recipe ideas
Preparation steps
Estimated nutrition

Consistent JSON Responses
All endpoints enforce strict JSON schemas. The API avoids unstructured AI output so responses stay safe and predictable.

Who Is This API For?

FoodFacts API fits teams building:

Fitness and calorie-tracking apps
Diet and wellness platforms
Recipe and meal-planning tools
Health-focused SaaS products
AI-powered food features

API Documentation

Base URLs

Authentication Group URL:

https://x95f-42hw-risi.m2.xano.io/api:QC35j52Y

FoodFacts API Group URL:

https://x95f-42hw-risi.m2.xano.io/api:GZXOANAS

Base URL:

https://x95f-42hw-risi.m2.xano.io/api

Authentication Strategy

FoodFacts API uses a hybrid authentication model:

Public endpoints allow anonymous access for testing and basic use. These include: foods/search, nutrition/estimate & nutrition/ingredients
Protected endpoints require Bearer tokens. These include: diet/plan, recipes/from-ingredients

This approach keeps onboarding simple while protecting AI-heavy operations.

Rate Limiting

To protect reliability and cost, we apply rate limiting to prevent abuse and stay within Gemini API limits (15 RPM for Flash).

redis.ratelimit {
  key = "recipes_fromingr_limit:" ~ $auth.id
  max = 15
  ttl = 60
  error = "Too many requests. Please try again in a minute."
}

API Endpoints

`/nutrition/ingredients`

Purpose: Analyze ingredients and return total calories & macros

Method: POST

Example Input:

{
  "ingredients": [
    "1 medium banana",
    "2 tbsp peanut butter"
  ]
}

Here we send a simple list of ingredients with quantities, and the API returns total calories, protein, carbs, and fats.

`/foods/search`

Purpose: Search nutrition data for a food item

Method: GET

Example Input:

/foods/search?query=apple

This endpoint lets developers search for standardized nutrition data for a food item, normalized.

`/nutrition/estimate`

Purpose: Estimate calories & macros from free-text

Method: POST

Example Input:

{
  "meal_description": "2 slices of pizza and a glass of coke"
}

Even when exact ingredients aren't known, developers can send a natural language description and get an estimated nutritional breakdown.

`/diet/plan`

Purpose: Generate a multi-day diet plan

Method: POST

Authentication: Required

Example Input:

{
  "goal": "weight loss",
  "days": 3,
  "diet_type": "vegetarian"
}

Based on the user's goal and preferences, the API generates a complete multi-day diet plan.

`/recipes/from-ingredients`

Purpose: Generate recipes from available ingredients

Method: POST

Authentication: Required

Example Input:

{
  "ingredients": ["chicken", "rice", "onion"]
}

Developers can send a simple list of ingredients, and the API returns complete recipes with steps and nutrition.

Demo

Video Link

Using Public Endpoints

1. Food Search

curl -X GET \
  "https://x95f-42hw-risi.m2.xano.io/api:GZXOANAS/foods/search?query=banana" \
  -H "Content-Type: application/json"

2. Nutrition Estimate

curl -X POST \
  'https://x95f-42hw-risi.m2.xano.io/api:GZXOANAS/nutrition/estimate' \
  -H 'Content-Type: application/json' \
  --data '{"meal_description":"Grilled chicken breast with brown rice and steamed broccoli"}'

3. Ingredient Analysis

curl -X POST \
  https://x95f-42hw-risi.m2.xano.io/api:GZXOANAS/nutrition/ingredients \
  -H "Content-Type: application/json" \
  -d '{
    "ingredients": [
      "1 medium banana",
      "2 tbsp peanut butter"
    ]
  }'

Using Protected Endpoints

To use protected endpoints, you first need to create an AUTH Token using auth/signup & auth/login endpoints.

Step 1: Sign Up

curl -X POST https://x95f-42hw-risi.m2.xano.io/api:QC35j52Y/auth/signup \
  -H "Content-Type: application/json" \
  -d '{
    "email": "test1@gg.com",
    "name": "Test",
    "password": "testpassword"
  }'

Step 2: Login

curl -X POST https://x95f-42hw-risi.m2.xano.io/api:QC35j52Y/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "test1@gg.com",
    "password": "testpassword"
  }'

Copy the "authToken" from the login response and use it in the following requests.

3. Diet Plan Generation

curl -X POST \
  https://x95f-42hw-risi.m2.xano.io/api:GZXOANAS/diet/plan \
  -H "Authorization: Bearer YOUR_AUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "goal": "weight_loss",
    "days": 30
  }'

4. Recipe Generation

curl -X POST \
  https://x95f-42hw-risi.m2.xano.io/api:GZXOANAS/recipes/from-ingredients \
  -H "Authorization: Bearer YOUR_AUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "ingredients": [
      "tomato",
      "cheese",
      "bread"
    ]
  }'

The AI Prompt I Used

Build a production-ready public REST API called "FoodFacts API".

This is a backend-only service (no UI) designed for third-party developers
building fitness, health, diet, and food applications.

The API must return structured JSON only and be ready for real-world usage.

Core features and endpoints:

1. POST /nutrition/ingredients  
Input: { ingredients: [string] }  
Behavior:
- Accept a list of ingredients such as "2 eggs", "1 cup milk"
- Use AI to estimate nutrition
- Return total calories, protein, carbs, fats
- Include a per-ingredient breakdown

2. GET /foods/search?query=  
Behavior:
- Search a food item by name
- Return nutrition facts per serving and per 100g
- Include category and portion information

3. POST /nutrition/estimate  
Input: { meal_description: string }  
Behavior:
- Accept a natural language meal description
- Estimate total calories, protein, carbs, and fats

4. POST /diet/plan  
Input: { goal: string, days: number }  
Behavior:
- Generate a day-wise AI-powered diet plan
- Include meals per day
- Include daily calorie targets
- Provide a grocery list and health tips

5. POST /recipes/from-ingredients  
Input: { ingredients: [string] }  
Behavior:
- Generate 3–5 recipes using the provided ingredients
- Include steps and estimated nutrition for each recipe

Technical requirements:
- Use API-first design
- Structured JSON responses only
- Clear request and response schemas
- Error handling for invalid input
- Ready for API key authentication and rate limiting
- No frontend or UI logic

This API should demonstrate best practices for a consumable public API
built with Xano and AI-powered external requests.

AI-Generated Database Schema

How I Refined the AI-Generated Code

⚙️ Challenge 1: Auto-Generated CRUD Endpoints

The platform automatically created ~20 CRUD-style API endpoints based on the prompt. These endpoints followed a standard pattern:

One or two function blocks per endpoint
Basic create/read/update/delete logic
No business rules, validations, or AI orchestration

Instead of that, we manually designed and implemented the core APIs that actually power the product.

For example, it created an endpoint called diet_plan, which looked like this:

// Query all diet_plan records
query diet_plan verb=GET {
  api_group = "FoodFacts API Group"

  input {
  }

  stack {
    db.query diet_plan {
      return = {type: "list"}
    } as $diet_plan
  }

  response = $diet_plan
}

Good part 😄: Later we used the Logic Assistant to create multiple endpoints by describing the intent of each API in natural language. The assistant generated accurate function blocks such as input validation, conditional logic, external API requests, and response handling.

The PROMPT we used with Logic Assistant looked like this:

You are building logic for a public API endpoint: POST /nutrition/ingredients.

Goal:
Analyze a list of food ingredients and return estimated nutrition using AI.

Input:
- ingredients: array of strings (required)
Example: ["2 eggs", "1 cup milk", "1 banana"]

Logic requirements:
1. Validate input:
- ingredients must be an array
- array must not be empty
- return a clear JSON error if invalid

2. Build an AI prompt that asks the model to:
- Estimate calories, protein, carbs, and fats for each ingredient
- Calculate total calories, protein, carbs, and fats
- Return JSON only (no explanations, no markdown)

Expected AI response format:
{
  "total_calories": number,
  "total_protein": number,
  "total_carbs": number,
  "total_fats": number,
  "breakdown": [
    {
      "item": string,
      "calories": number,
      "protein": number,
      "carbs": number,
      "fats": number
    }
  ]
}

3. Use an external API request to call an AI model 
(Google Gemini 1.5 Flash or equivalent) to generate nutrition estimates.

4. Parse and validate the AI JSON response.
- If parsing fails, return a graceful error message.

5. Return a clean JSON response with:
- total calories
- total protein
- total carbs
- total fats
- per-ingredient breakdown

Additional constraints:
- No database writes required
- Stateless request
- JSON responses only
- Production-ready error handling
- Optimized for a public, API-key protected endpoint

The output Logic Assistant generated was this:

// Estimates nutrition facts for a list of ingredients using AI.
query estimate_nutrition verb=POST {
  api_group = "FoodFacts API Group"

  input {
    // List of ingredients to analyze (e.g., "1 cup rice", "100g chicken")
    text[] ingredients
  }

  stack {
    // Validate that the ingredients array is not empty
    precondition (($input.ingredients | count) > 0) {
      error_type = "inputerror"
      error = "Ingredients list cannot be empty."
    }

    // Construct the AI prompt
    var $prompt {
      value =
        "Estimate the nutrition facts for these ingredients: "
        ~ ($input.ingredients | join: ", ")
        ~ ". Return strictly a JSON object with keys: "
        ~ "total_calories (int), total_protein_g (decimal), "
        ~ "total_carbs_g (decimal), total_fats_g (decimal), "
        ~ "and ingredients (array of objects with name, calories, "
        ~ "protein_g, carbs_g, fats_g). "
        ~ "Do not use markdown formatting."
    }

    // Call Google Gemini API
    api.request {
      url =
        "https://generativelanguage.googleapis.com/v1beta/models/"
        ~ "gemini-2.5-flash:generateContent?key="
        ~ $env.GEMINI_API_KEY
      method = "POST"
      params = {
        contents: [
          {
            parts: [
              { text: $prompt }
            ]
          }
        ]
      }
      headers = [] | push: "Content-Type: application/json"
    } as $ai_response

    // Parse the response
    try_catch {
      try {
        var $raw_content {
          value =
            $ai_response.response.result.candidates[0]
              .content.parts[0].text
        }

        // Clean potential markdown formatting just in case
        var $clean_content {
          value =
            $raw_content
              | replace: "```

json", ""
              | replace: "

```", ""
              | trim
        }

        var $nutrition_data {
          value = $clean_content | json_decode
        }
      }

      catch {
        throw {
          name: "inputerror"
          value = "Unable to process nutrition data from AI response."
        }
      }
    }
  }

  response = $nutrition_data
}

⚙️ Challenge 2: Schema Inconsistencies

The above XanoScript had some issues:

The prompt explicitly referenced the endpoint name nutrition/ingredients, but the logic assistant named it estimate_nutrition
The output schema AI generated was (this was the biggest difference):

total_calories (int)
total_protein_g (decimal)
total_carbs_g (decimal)
total_fats_g (decimal)
ingredients: [
  { name, calories, protein_g, carbs_g, fats_g }
]

However, it should have been the following, as stated in the prompt schema:

total_calories (number)
total_protein (number)
total_carbs (number)
total_fats (number)
breakdown: [
  { item, calories, protein, carbs, fats }
]

The refined XanoScript we used:

// Estimates nutritional information for a list of ingredients using AI.
query "nutrition/ingredients" verb=POST {
  api_group = "FoodFacts API Group"

  input {
    // List of ingredients to analyze (e.g., ["1 cup rice", "100g chicken"])
    text[] ingredients
  }

  stack {
    // Validate that the input array is not empty
    precondition (($input.ingredients | count) > 0) {
      error_type = "inputerror"
      error = "The ingredients list cannot be empty."
    }

    // Construct the prompt for the AI model
    var $prompt {
      value =
        "Analyze the following ingredients: "
        ~ ($input.ingredients | join: ", ")
        ~ ". Provide a nutritional estimation. "
        ~ "Return ONLY a raw JSON object (no markdown formatting, no code blocks) "
        ~ "adhering strictly to this schema: "
        ~ "{ \"total_calories\": number, "
        ~ "\"total_protein\": number, "
        ~ "\"total_carbs\": number, "
        ~ "\"total_fats\": number, "
        ~ "\"breakdown\": [ "
        ~ "{ \"item\": string, \"calories\": number, "
        ~ "\"protein\": number, \"carbs\": number, \"fats\": number } "
        ~ "] }. "
        ~ "Ensure all numeric values are returned as numbers, not strings."
    }

    // Call Google Gemini 2.5 Flash API
    api.request {
      url =
        "https://generativelanguage.googleapis.com/v1beta/models/"
        ~ "gemini-2.5-flash:generateContent?key="
        ~ $env.GEMINI_API_KEY
      method = "POST"
      params = {
        contents: [
          {
            parts: [
              { text: $prompt }
            ]
          }
        ]
      }
      headers = [] | push: "Content-Type: application/json"
    } as $gemini_response

    // Extract the raw text from the response
    var $raw_content {
      value =
        $gemini_response.response.result
          .candidates[0].content.parts[0].text
    }

    // Clean the response text by removing markdown artifacts if present
    var $cleaned_content {
      value =
        $raw_content
          | replace: "```

json", ""
          | replace: "

```", ""
          | trim
    }

    // Attempt to parse the cleaned text into a JSON object
    try_catch {
      try {
        var $nutrition_data {
          value = $cleaned_content | json_decode
        }
      }

      catch {
        throw {
          name = "ParsingError"
          value =
            "Failed to parse AI response into valid JSON. Raw response: "
            ~ $cleaned_content
        }
      }
    }
  }

  response = $nutrition_data
}

Similarly, we made improvements to other endpoints as well.

⚙️ Challenge 3: API Rate Limiting

One of the main challenges we faced was working within the API limits of Gemini 2.5 Flash. Since multiple endpoints depend on AI-generated responses, we had to be careful about how often requests were made and ensure that rate limiting was applied consistently. This required us to design our endpoints defensively, validate inputs early, and avoid unnecessary AI calls. Handling structured JSON responses reliably from the AI model also required iterative prompt refinement to keep outputs predictable for a production API.

⚙️ Challenge 4: Exploring Xano Actions

We also explored using Xano Actions to abstract shared logic such as validation and response normalization. While the concept is powerful, we found that integrating Actions into existing endpoints required careful understanding of how data flows between Actions and API stacks. Although Xano provides resources and videos around Actions, we realized that for this project, keeping the logic directly inside endpoints allowed us to move faster and maintain clarity. This exploration was still valuable, as it helped us better understand when Actions are most appropriate in real-world backends.

My Experience with Xano

What Helped Most When Using Xano

Visual logic builder for clear and debuggable flows
Built-in debugger for inspecting live requests and responses
Simple external API integration with secure key storage
Built-in authentication and rate limiting
Structured error handling
Fast iteration from idea to stable API

The Logic Assistant was particularly valuable for rapidly prototyping endpoint logic. While it didn't always produce perfect code on the first try, it significantly reduced development time by generating a solid foundation that we could refine.

The visual nature of Xano's function stack builder made it easy to understand data flow and debug issues. Combined with the built-in request debugger, we could quickly identify and fix problems in our API logic.

Team Submission:

dev.to/mohitb_twt - mail.mohitbisht@gmail.com
dev.to/deebi9 - deepanshudb1@gmail.com

Cloudflare Went Down - Here's What Really Happened Today

Mohit Bisht — Tue, 18 Nov 2025 18:30:25 +0000

Today wasn’t normal for the internet.

One moment everything was fine.
Next moment, half the apps we use daily stopped working.

ChatGPT wasn’t loading.
X (Twitter) threw errors.
Udemy, Canva, all struggling.

If your apps felt broken, the problem wasn’t with your WiFi.
It was Cloudflare.

And when Cloudflare goes down, the internet feels it everywhere.

I checked updates from Reuters, major news outlets, and Cloudflare’s own status page.

Here’s the simplest developer-friendly summary of what happened today.

Cloudflare sits between users and most websites

When you open a website, your request usually goes to Cloudflare first.

Companies use it for:

CDN
WAF
DDoS protection
Caching
Routing
API security

So when Cloudflare slows down, every app behind it slows down too.

What actually went wrong today

Cloudflare shared that one of their internal services received unexpected traffic.

Not from attackers.
Not from unknown IPs.
But from their own network, just at a scale they didn’t expect.

They didn’t name the service, but it was critical enough that once it got overloaded, other systems started failing.

That’s why:

ChatGPT
X
Udemy
Canva

all showed the same error:
“We can’t reach the server right now.”

It wasn’t their fault.
The layer beneath them was unhealthy.

This outage hit developers too

A lot of CI/CD pipelines broke because dependency downloads failed.

Examples:

Java JAR downloads
npm installs
Docker image pulls
API calls through Cloudflare

Even if your app doesn’t use Cloudflare directly, some service your tools depend on probably does.

This is how interconnected the internet has become.

Cloudflare pushed a fix quickly

Around 14:42 UTC, Cloudflare rolled out a fix.

By 14:57 UTC, most services started coming back.

Some people still saw small glitches afterward, but the worst was over quickly.

Cloudflare will publish a full RCA soon, which will explain exactly what happened.

I’ll write a follow-up post when that drops.

For developers, there’s a lesson in this

Incidents like today remind us:

One dependency can break many systems
Monitoring should cover underlying infrastructure, not just your app
Fallback paths matter
External CI/CD dependencies can fail anytime

The modern internet rests on a few critical layers and Cloudflare is one of the biggest.

What was your experience?

Did your app break?
Did your build pipeline fail?
Did your users complain?

Drop your experience below it’ll help others understand the impact.

If you want calm, simple breakdowns of incidents like this, or stories about cloud, dev, and building real-world systems — you can follow me here.

🎮 Exploring Amazon Q CLI Building a Simple Tic-Tac-Toe Game

Mohit Bisht — Tue, 10 Jun 2025 13:28:56 +0000

Hello everyone!

I recently participated in the #AmazonQCLIGameChallenge, an exciting opportunity to build a game using the new Amazon Q CLI – an AI-powered coding assistant from AWS. As someone who's always learning and exploring new tools, I decided to tackle a classic: a simple Tic-Tac-Toe game using Q CLI and Python.

In this blog post, I'll walk you through my experience using Amazon Q CLI to build the game, share my key learnings, and show you how you can try it out for yourself!

🧠 What is Amazon Q CLI? Your AI-Powered Coding Partner

Amazon Q CLI is a groundbreaking AI-powered command-line tool from AWS. Imagine having a knowledgeable coding partner right in your terminal, available 24/7. That's exactly what Q CLI offers!

It empowers you to write, debug, and explore code simply by chatting with it.

You can ask Amazon Q CLI to:

Generate code snippets
Explain complex functions
Identify and fix bugs
Provide architectural insights

It’s like having ChatGPT, but seamlessly integrated into your terminal workflow.

👉 Learn more on the Official Amazon Q CLI Page

⚙️ My Setup: Getting Started with Amazon Q CLI

Here’s how I set up my environment to build the game:

1. Sign Up for an AWS Builder ID

This is your gateway to accessing AWS services and tools.
👉 Get Your AWS Builder ID Here

2. Install Amazon Q CLI

🔹 For Windows:

👉 Amazon Q CLI Installation Guide for Windows

🔹 For Linux (Ubuntu):

# Update your machine and install libfuse2
sudo apt-get update
sudo apt install libfuse2

# Download and install Amazon Q CLI
curl --proto '=https' --tlsv1.2 -sSf https://desktop-release.q.us-east-1.amazonaws.com/latest/amazon-q.deb -o amazon-q.deb
sudo apt install -y ./amazon-q.deb

# Login to Q CLI
q login

3. Install Python

Since I was building a terminal-based game, Python was a great choice due to its simplicity and clean syntax.

4. Start Amazon Q CLI Chat

Once everything was installed, I opened my terminal and ran:

amazonq chat

🎮 Building the Tic-Tac-Toe Game with Amazon Q CLI

With the chat session open, I asked:

"Create a Tic Tac Toe game in Python that allows two players to play turn by turn."

To my surprise, Amazon Q CLI instantly gave me the full Python code. It also explained each part of the logic when I asked, making it easy to understand and customize.

Within minutes, I had a working version of the game, ready to play in the terminal. This helped me understand:

How to manage turn-based logic
How to store and check game state
Simple Python tricks for cleaner CLI output

🖼️ Game Screenshots

▶️ Demo Video

Want to see it in action?

🎥 Watch the YouTube Demo

💻 Get the Code

Feel free to check out the code and try it yourself:

🔗 GitHub – Tic Tac Toe Game Using Amazon Q CLI

My Experience with Amazon Q CLI

Amazon Q CLI turned a simple game idea into an engaging learning experience. It wasn’t just about generating code — it was about understanding the logic and building confidence as a developer.

Whether you’re just getting started or you’re looking to speed up your development process, I highly recommend giving Amazon Q CLI a try. It's like having an intelligent teammate sitting right inside your terminal.

Thanks for reading! If you enjoyed this post, give it a like, drop a comment, or share it with a fellow dev! 🚀

What The Pursuit of Happyness Taught Me About Solving Problems as a Developer

Mohit Bisht — Thu, 20 Mar 2025 06:13:51 +0000

As a developer and student, I'm constantly learning, failing, and figuring things out one problem at a time. Recently, I watched The Pursuit of Happyness again, and it hit differently this time.

The hustle. The late nights. The mindset of "I may not know everything, but I know how to find the solution." It reminded me so much of the developer journey—especially when you're just starting out or working on big goals with limited resources.

So I wanted to share a quick reflection — my favorite dialogue, key takeaways, and how this movie relates to life in tech. Maybe it'll resonate with you too.

🎬 Favorite Dialogue & Why

“Don’t ever let somebody tell you, you can’t do something. Not even me. You got a dream, you gotta protect it.”

— Chris Gardner

This line stood out because in tech — whether you're starting to code, building your first project, or applying for that dream job — there’s always someone who’ll doubt you, maybe even yourself. But protecting your dream and showing up daily matters more than anyone's opinion.

Another favorite of mine:

“If someone asks me a question and I don’t know the answer, I’ll say I don’t know. But I know how to find the solution.”

This line is the developer mindset in a nutshell. You don't need to have all the answers — just the curiosity and drive to figure them out.

🧠 My Personal Review

The Pursuit of Happyness is more than just a feel-good film — it's a lesson in grit, patience, and believing in yourself when life keeps saying "no." Watching Chris Gardner go from struggling to success reminded me that consistent effort pays off, even when the results aren’t immediate.

📚 What I Learned (and How It Helps in Tech)

Persistence beats talent — Showing up and doing the work every day builds results.
Learning is a lifelong process — Whether it’s a job interview or a new framework, not knowing is okay as long as you’re willing to learn.
Mindset matters — Staying positive even when you’re stuck helps you push through.
Solve problems, one at a time — Like debugging, life’s challenges are easier when broken down.

💻 How It Connects to What I Learn in Class

In class, we often face tough assignments, unclear problems, or projects that seem too big. This movie reminded me of things like:

Problem-solving frameworks — Breaking problems into steps.
Resilience and adaptability — Especially in coding, where things rarely work on the first try.
Effective communication — Being honest about what you know and what you need to learn, like in teamwork or interviews.

Final Thoughts 💬

We all face setbacks — in life, in code, in careers. But movies like this remind us that the process matters and that every challenge is a step toward something greater.

If you're on your own dev journey, just remember:

You may not know everything now, but you know how to find the solution.

Would love to hear — what movie has inspired you as a developer? Drop it in the comments! 🎥💻

From Photos to Pixels: Building a Retro Art Transformer with GitHub Copilot

Mohit Bisht — Mon, 20 Jan 2025 08:00:00 +0000

This is a submission for the GitHub Copilot Challenge : Transitions and Transformations

What I Built

Hey fellow devs! 👋 I wanted to share something cool I built for the GitHub Copilot Challenge. I made this fun web app called Pixel Art Transformer that turns your regular photos into pixel art. You know, like those retro gaming graphics we all love!

So basically, you can upload any image, and the app transforms it into pixel art. You can play around with different effects, get color palettes from your image, and save your creations. I wanted to make something that's both fun to use and lets people get creative without needing to be art experts.

The Cool Stuff You Can Do

Turn any photo into pixel art (super satisfying to watch!)
Get a matching color palette from your image
Add some funky effects like grayscale or sepia
Save your masterpiece as PNG, JPG, or even GIF

I built it using Next.js and Tailwind CSS, with some Canvas API magic thrown in for the image stuff.

Demo

Check out the live app here: https://pixel-art-fawn.vercel.app/

Repo

Check out the project on GitHub: https://github.com/Mohiit70/pixel-art

Copilot Experience

Let me tell you - Copilot was like having a coding buddy who never gets tired! Here's how it helped:

It was amazing at suggesting code, especially for the tricky pixel calculation stuff
Helped me create React components super quickly
Made writing Tailwind CSS classes way less painful
Caught some bugs I wouldn't have spotted right away
Helped clean up my messy code (we all have those moments!)

GitHub Models

I didn't use GitHub Models specifically for LLM prototyping in this app. However, GitHub Copilot's code suggestions and intelligent autocomplete significantly boosted my productivity and allowed me to focus on the creative aspects of the project.

Conclusion

Building this was honestly so much fun! I learned a ton about breaking down big problems into smaller pieces, and Copilot made the whole process much smoother.

If you're interested in checking it out or maybe even contributing, the project is up on GitHub. Would love to hear what you think or see what kind of pixel art you create!

Thanks for reading, and huge thanks to the GitHub Copilot Challenge for giving me the push to build this! ✨

P.S. Drop a star on the repo if you like it! 😉

Using LLaMA Models with Groq: A Beginner's Guide

Mohit Bisht — Sun, 29 Sep 2024 10:51:17 +0000

Hey there, AI enthusiasts! Today, we're going to learn how to use LLaMA models with Groq. It's easier than you might think, and I'll guide you step-by-step on how to get started.

In this blog, we will explore how to use free AI models, discuss running them locally, and leverage Groq for API-powered applications. Whether you're building a text-based game or an AI-powered app, this guide will cover everything you need.

What You'll Need

Python installed on your computer
A Groq API key (you can get one from their website)
Basic knowledge of Python (but don't worry, we'll keep it simple!)
A curiosity to explore AI in creative ways!

Step 1: Set Up Your Environment

First, let's install the Groq library. Open your terminal and run:

pip install groq

Step 2: Import the Library and Set Up Your API Key

Now, let's write some Python code. Create a new file called llama_groq_test.py and add these lines:

import os
from groq import Groq

# Set your API key
api_key = os.environ.get("GROQ_API_KEY")
if not api_key:
    api_key = input("Please enter your Groq API key: ")
    os.environ["GROQ_API_KEY"] = api_key

# Create a client
client = Groq()

This method is more secure as it doesn't hardcode the API key directly in your script.

Step 3: Choose Your Model

Groq supports different LLaMA models. For this example, we'll use "llama2-70b-4096". Let's add this to our code:

model = "llama2-70b-4096"

Step 4: Send a Message and Get a Response

Now for the fun part! Let's ask LLaMA a question. Add this to your code:

# Define your message
messages = [
    {
        "role": "user",
        "content": "What's the best way to learn programming?",
    }
]

# Send the message and get the response
chat_completion = client.chat.completions.create(
    messages=messages,
    model=model,
    temperature=0.7,
    max_tokens=1000,
)

# Print the response
print(chat_completion.choices[0].message.content)

Step 5: Run Your Code

Save your file and run it from the terminal:

python llama_groq_test.py

You should see LLaMA's response printed out!

Bonus: Having a Conversation

Want to have a back-and-forth chat? Here's a simple way to do it:

while True:
    user_input = input("You: ")
    if user_input.lower() == 'quit':
        break

    messages.append({"role": "user", "content": user_input})

    chat_completion = client.chat.completions.create(
        messages=messages,
        model=model,
        temperature=0.7,
        max_tokens=1000,
    )

    ai_response = chat_completion.choices[0].message.content
    print("AI:", ai_response)

    messages.append({"role": "assistant", "content": ai_response})

This code creates a loop where you can keep chatting with LLaMA until you type 'quit'.

Free AI Options: Running LLaMA Locally

Many developers prefer free, open-source models like LLaMA by Meta because they can be run locally without costly API charges. While using APIs like OpenAI or Gemini can be convenient, the open-source nature of LLaMA offers more control and flexibility.

It's important to note that running LLaMA models locally often requires significant computational resources, especially for larger models. However, for those with the right hardware, this can lead to substantial savings, especially when running your projects without worrying about API costs.

You can test smaller LLaMA models on your local machine. For larger-scale projects or if you lack the necessary hardware, tools like Groq provide a simple way to integrate AI with just an API key.

Star Quest: My AI-Powered Sci-Fi Game

Speaking of AI-powered projects, I recently built a sci-fi text-based game called Star Quest using LLaMA (via Groq's API) and Next.js. The game allows players to explore a narrative-driven world, making choices that affect the storyline.

Here's a sneak peek into how it works:

The user inputs a choice to guide the story.
LLaMA processes the user's input, generating a dynamic response that shapes the next part of the plot.
The game's logic and API integration allow for endless combinations, making it a truly interactive experience.

If you'd like to see the full project and try it out yourself, check out my GitHub repo here: https://github.com/Mohiit70/Star-Quest

You can clone the repository and start exploring sci-fi narratives powered by AI!

Wrapping Up

That's it! You now know how to use LLaMA with Groq to create AI-powered apps or even build your own games. Here's a quick summary:

Install the Groq library.
Set up your API key securely.
Choose the LLaMA model.
Send and receive messages from the AI.
Experiment with creating your own AI-based applications, like my Star Quest text-based game.

I hope this guide has inspired you to explore the world of AI. Feel free to ask any questions or check out my Star Quest project on GitHub!

Happy Coding!