DEV Community: Samir

My Cerebras Hackathon Journey: How TasksForge Helped Me Build an AI App for Kids in 8 Hours

Samir — Wed, 04 Jun 2025 04:53:25 +0000

Context:

A couple of weeks ago, I took part in an exciting 8-hour hackathon organized by Cerebras, spotlighting their powerful new LLAMA 4 LLM deployment. The event hosted on Lu.ma challenged developers to build innovative AI-powered apps fast.

Spoiler alert: I didn’t win. But the project that did was seriously impressive a Satellite Signal Log Analyzer that parsed satellite radio logs in real time, with interference risk scores, visual trend charts, log comparisons, and more, all powered by Llama 4 and a sleek orange/white UI. Totally deserved the win.

As for me, I’ve been a programmer analyst for over 15 years, building web apps and CRM systems across a wide range of tech stacks Python, Next.js, PHP, Java, you name it. I’ve tackled everything from full-stack dev to backend architecture. But even with that experience, hackathons are a different kind of beast. Fast pace. High pressure. No time to overthink.

My idea was to develop an AI-powered summarizing blog app for kids, a fun, educational platform that takes regular blog content and simplifies it for younger readers using LLMs. I knew I wanted something lightweight, easy to deploy, and most importantly, user-friendly for kids.

But the clock was ticking, and I wasn’t sure where to start.

That’s when I reached for my secret weapon: TasksForge.ai. It helped me break the project into manageable chunks, map out the architecture, and stay focused throughout the sprint. Combine that with a little “vibe coding” magic, and I was off and running.

🛠️ How I Did It: From “Petit Prince” to Project Plan with TasksForge

Once I locked in my idea: an AI-powered blog summarizing app for kids. I knew I needed to quickly shape it into something concrete. I even had the perfect name in mind: “Petit Prince”. Inspired by the timeless tale, I wanted the app to be equally poetic, thoughtful, and child-friendly, something that both parents and kids could use together.

I had a rough concept: parents would paste a blog link or article into the app, select their child’s age range, and let the AI assistant rewrite the content in a simplified, kid-friendly tone. The core of the app would be powered by Llama 4, through Cerebras’s inference API.

I also envisioned a gentle, intuitive UI accessible enough for a child, but practical for a parent. With only hours to build, I needed clarity. So I turned to my secret productivity engine: TasksForge.ai, using this prompt:

As a parent, I want to share a blog post or article with my child, using the app AI assistant to summarize and rewrite the blog/article to be read by a kid. As a parent, I want to have an input text box or paste a blog link, and radio options to choose the child's age range. I want to use Llama 4 LLM provided by the Cerebras inference platform.

TasksForge.ai helped me unpack the idea, generate structured user stories, and tailor the implementation to fit my preferred tech stack. After a few iterations and a back-and-forth conversation with the TasksForge.ai AI assistant tool, I was able to refine the core requirements and user stories, aligning them perfectly with the vision in my head.

I also made sure to scope the project to the tech stack I’m most comfortable with, focusing on quick deployment and simplicity. I had a clear architecture, scoped features, and a realistic build plan all within minutes. You can even explore my exported project board here:
👉 Petit Prince Hackathon Project Board

💡 Choosing a Platform: Why I Went with val.town

For deployment, I wanted something fast, free, and frictionless. That’s when I chose val.town, a lightweight, serverless environment for deploying JavaScript/TypeScript apps. I was curious to try it, and it turned out to be a pleasant surprise. It gave me quick, no-hassle deployment and even came with a helpful system prompt for "Vibe coding", so I keep focused hackathon sprint.

🤖 AI-Augmented Workflow: TasksForge + Prompt Libraries + Aider

To move efficiently from planning to implementation, I followed a structured, AI-assisted development workflow inspired by this video AI Coding Tools: Prompt Libraries & Workflow Strategies for Maximum Impact!. The approach emphasizes using prompt libraries to consistently guide coding agents like Aider and Cody through a repeatable, smart dev loop.

Here’s how I applied it:

I used TasksForge.ai to generate clear, actionable user stories and requirements.

Then, using a structured prompt library, I passed those user stories into Aider chat, my AI coding assistant.

Aider chat, the best "Vibe Coding" tool ever, helped incrementally build features handling UI generation, backend integration, and logic while I focused on high-level design and creative problem solving, accelerating development without losing quality.

By combining TasksForge.ai’s structured ideation with a prompt-driven AI coding loop, I was able to go from vision to working prototype in record time.

🚀 The Final Result: Petit Prince App

You can try the live version of my app here: 👉 petitprince.val.run

Petit Prince is a thoughtful, security-aware, and mobile-friendly AI assistant designed for parents who want to share web content with their children in a safe, clear, and engaging way.

🌟 Key Features:

✅ Safety & Security First: The app doesn’t just summarize, it also filters for child-appropriate content. This ensures that inappropriate or overly complex language never reaches your child.
🧠 AI-Powered Summarization & Simplification: Parents can paste in an article URL or a block of text, then choose the target age range. The app uses Llama 4 via Cerebras API to rewrite the content in a clear, simplified tone suitable for kids.
📱 Mobile-Friendly by Design: The UI was designed to work smoothly on phones and tablets. It’s perfect for on-the-go learning moments, bedtime stories, or curious questions while commuting.
📤 Easy to Share: The app can be easily shared with other parents or family members through Facebook Messenger, allowing for collaborative parenting and meaningful family interactions.
🎯 Distraction-Free Content: One of the core ideas was to strip out casual web distractions, no ads, no cluttered layouts, no unrelated links. Just clean, focused content rewritten for kids to read, explore, and learn with curiosity.

Want to Learn More?
Check out the Petit Prince Documentation to see how the app works, the technologies involved, and the API logic behind it.

See some already generated blogs here

🎉 Conclusion

I didn’t win the hackathon, but honestly? I had an amazing time building Petit Prince, and I’m proud of what I was able to deliver in just eight hours.

Thanks to a powerful combo of:

TasksForge.ai (for scoping, planning, and rapid architecture), and the prompt library workflow featured in this video.

I submitted a fully functional project one hour before the deadline, complete with a live deployment, documentation, and a delightful concept I’m genuinely excited to keep evolving.

Whether you win or not, hackathons are about creative momentum, community, and pushing your limits. And this one definitely delivered.

Monitoring your platform app with UV and tasksMonitorTool: A Lightweight & Secure Approach

Samir — Sun, 25 May 2025 22:43:35 +0000

In this post, I want to share a minimal and efficient method I implemented to monitor the health and system resources of the tasksforge.ai SaaS platform using the simple script tool: tasksMonitorTool, powered by the ultra-fast UV Python runtime.

🧠 Context: Managing the tasksforge.ai Platform

tasksforge.ai is structured as a modular, secure SaaS platform where:

The backend (BE) is isolated inside a private internal network, only accessible by the Next.js frontend (FE) that handles user interactions.
A separate SaaS management layer is under development to manage:
- Subscriptions
- User permissions
- Server health monitoring (DB, website, APIs, system resources)

❌ Option 1: Internal /api/health Endpoint with psutil

One approach is to integrate psutil directly into the backend and expose a /api/health endpoint.

But this presents several drawbacks:

Introduces extra load on the backend.
Violates the isolation principle (monitoring is now tied to app runtime).
Not scalable for short interval queries (e.g., every 10s).

✅ Option 2: External Monitor via UV Script and SSH

To decouple monitoring from the backend and maintain performance, I implemented a separate, isolated monitoring script that:

Is written in Python
Runs using UV for speed and isolation
Is executed remotely via SSH from my local machine

This keeps the backend clean and the resource monitoring fully externalized.

🔒 Security Concerns: SSH & Internal Network Design

Security was central to this approach. Here's how I designed it:

🧱 Network Isolation

The backend server is inside a private internal network, with no direct internet exposure.
Only the frontend (Next.js) has access to the backend APIs; it acts as a gateway.
The SaaS management platform is also isolated and lives in a separate internal network.

🔐 SSH Access Model

Access to monitoring is performed via SSH using public/private key authentication only.
No passwords. No open ports to the world.
The monitor script can only be invoked through a secure SSH tunnel:

ssh -i ~/.ssh/forge-monitor user@internal-ip 'uv run  ~/monitor/monitor.py --json'

🔄 SSH Tunnel (if remote access is required)

To manage from the internet, I occasionally use SSH tunneling:

ssh -i ~/.ssh/forge-monitor -L 9000:localhost:9000 user@gateway-server

This maintains full encryption, access control, and keeps internal services hidden from the public internet.

🧠 The golden rule: internal services are never directly exposed — they are reachable only through private, authenticated tunnels.

⚙️ How the Monitor Works

The tool checks:

CPU, memory, and disk usage
Database connection health
Backend/website availability via HTTP requests or sockets Run It (Locally or via SSH):

ssh user@server 'uv run ~/monitor/monitor.py --json'

Output example

{
    "status": "healthy",
    "cpu_usage": 11.6,
    "memory_total": 33325473792,
    "memory_available": 10426048512,
    "memory_used": 20279836672,
    "memory_percent": 68.7,
    "disk_total": 980799373312,
    "disk_used": 339543687168,
    "disk_free": 591358361600,
    "disk_percent": 36.5,
    "disk_read_bytes": 21832974848,
    "disk_write_bytes": 491035527168
}

Or use a custom alias:

alias checkforge="ssh user@server '~/monitor/run_monitor.sh'"
checkforge

🖼️ Visual Output

From the command line

Integration into a saas platform management app

🧩 Conclusion

This approach ensures:

✅ No performance hit to the AI backend
✅ Full security via SSH tunneling and network isolation
✅ Ease of access for DevOps without needing public endpoints

Check out the tool here:
🔗 GitHub – tasksMonitorTool

I’ll continue sharing how I scale and secure the tasksforge.ai platform — stay tuned!

Breaking Change: Making `tasks_prompts_chain` Agnostic and More Powerful

Samir — Mon, 07 Apr 2025 04:25:01 +0000

Welcome, developers and AI enthusiasts! Today, I'm excited to share a major update to the tasks_prompts_chain library. This update introduces a breaking change that not only makes the library completely agnostic regarding the LLM SDK you use but also enhances how responses are handled, giving you the flexibility to choose between streaming and batch processing.

In this tutorial, we'll cover:

Why this update is essential: Achieving SDK-agnosticism and flexible response handling.
How to initialize your chain with multiple LLM configurations.
How to define prompts with explicit LLM selection.
How to stream responses in real time or wait for complete outputs to access each prompt's result individually.
Preparing for future integrations with Tasksforge.ai.

Let's dive in!

Why the Update? SDK-Agnosticism and Flexible Response Handling

When I first built tasks_prompts_chain, it was designed to depend solely on openai.AsyncOpenAI. However, as more projects adopted the library, it became clear that a one-size-fits-all approach wasn’t enough. Projects often have varying needs and may prefer different LLM SDKs.

SDK-Agnosticism

With this update, tasks_prompts_chain is now agnostic—supporting not only AsyncOpenAI but also AsyncCerebras and AsyncAnthropic. This means you’re no longer locked into a single LLM SDK. You pass your chosen LLM SDK to TasksPromptsChain() during initialization, giving you the freedom to select the best tool for your project. And don’t worry—more SDKs will be supported in the future!

Flexible Response Handling

In addition to SDK flexibility, the update introduces a versatile response-handling mechanism. You can now choose between streaming responses in real time or waiting until the entire chain has finished processing, after which you can access each prompt's output individually. This flexibility lets you inspect and debug outputs at your own pace.

Step 1: Initializing the Chain with LLM Configurations

The first step is to set up your chain by passing a list of LLM configurations. This centralizes the SDK setup, ensuring your project isn’t forced to stick with one implementation.

Below is an example configuration:

from tasks_prompts_chain import TasksPromptsChain
from tasks_prompts_chain.llm import AsyncOpenAI, AsyncAnthropic, AsyncCerebras

llm_configs = [
    {
        "llm_id": "gpt",  # Unique identifier for this LLM
        "llm_class": AsyncOpenAI,  # Your chosen LLM SDK class
        "model_options": {
            "model": "gpt-4o",
            "api_key": "your-openai-api-key",
            "temperature": 0.1,
            "max_tokens": 4120,
        }
    },
    {
        "llm_id": "claude",  # Unique identifier for this LLM
        "llm_class": AsyncAnthropic,  # Your chosen LLM SDK class
        "model_options": {
            "model": "claude-3-sonnet-20240229",
            "api_key": "your-anthropic-api-key",
            "temperature": 0.1,
            "max_tokens": 8192,
        }
    },
    {
        "llm_id": "llama",  # Unique identifier for this LLM
        "llm_class": AsyncCerebras,  # Your chosen LLM SDK class
        "model_options": {
            "model": "llama-3.3-70b",
            "api_key": "your-cerebras-api-key",
            "base_url": "https://api.cerebras.ai/v1",
            "temperature": 0.1,
            "max_tokens": 4120,
        }
    }
]
# Initialize your chain with the LLM configurations
chain = TasksPromptsChain(llm_configs=llm_configs, "my system Prompt", final_result_placeholder="project_analysis", system_apply_to_all_prompts=False)

Step 2: Defining Prompts with Explicit LLM Selection

Once your chain is initialized, the next step is to define your prompts. Each prompt can now specify which LLM to use by including an llm_id attribute. This explicit routing lets you control the execution flow of your prompt chain.

For example:

prompts = [
    {
        "name": "generate_idea",
        "prompt": "Give me a cool project idea about {{ topic }}",
        "output_format": "MARKDOWN",
        "output_placeholder": "elaboration",
        "llm_id": "claude"  # Use the 'claude' LLM for this prompt
    },
    {
        "name": "generate_description",
        "prompt": "Write a detailed README for: {{ elaboration }}",
        "output_format": "MARKDOWN",
        "output_placeholder": "doc_readme",
        "llm_id": "gpt"  # Use the 'gpt' LLM for this task
    }
]

By including the llm_id in each prompt, you gain granular control over which language model processes each task

Flexible Response Handling: Streaming vs. Batch Processing

One of the most exciting improvements is how the library handles responses. You now have two modes available:

1. Streaming Response

If you prefer real-time feedback, you can stream responses as they come in. For example, printing each response chunk:

async for response in chain.execute_chain(prompts):
    print(response)

2. Batch Response Processing

Alternatively, you might prefer to wait until all responses are received. When the chain emits the special marker Done, you can then access each prompt’s output individually. Here's an example:

async for response in chain.execute_chain(prompts):
    # Optionally, print interim chunks:
    # print(response)

    # When the final output is ready:
    if response == "<tasks-sys>Done</tasks-sys>":
        print("\nFinal Results:\n")
        for placeholder in [
            "elaboration", 
            "doc_readme"
        ]:
            print(f"\n{placeholder}:")
            print(chain.get_result(placeholder))

This approach offers you full control: either enjoy real-time outputs or wait for complete responses to process further.

Preparing for the Future: Integration with Tasksforge.ai

These improvements in tasks_prompts_chain are just the beginning. With the library now SDK-agnostic and featuring flexible response handling, it’s perfectly poised for deeper integration with Tasksforge.ai. Imagine a platform where you can effortlessly swap LLMs, inspect individual step outputs, and build robust AI workflows—all while maintaining complete freedom over your chosen SDK.

Getting Started

eady to harness the power of a more flexible and powerful prompt chain? Follow these steps:

Update your initialization: Pass your preferred LLM SDKs via the llm_configs.

Define your prompts: Use the llm_id attribute to route tasks to your chosen LLM.

Choose your response mode: Stream in real time or process outputs in batch—whichever suits your workflow.

For more details and advanced examples, check out the updated documentation:
👉 tasks_prompts_chain on GitHub

Final Thoughts

Breaking changes can be a bit daunting, but they’re a vital step in evolving our tools to be more flexible and powerful. With this update, tasks_prompts_chain is no longer tied to a specific LLM SDK and offers you a choice in response handling. Whether you're debugging a complex prompt chain or building scalable AI workflows, these changes are designed to enhance your productivity.

I’m excited to see how you integrate these improvements into your projects—and I can’t wait for you to experience the full potential when integrated with Tasksforge.ai. Your feedback is invaluable, so please share your experiences, ideas, or any challenges you encounter.

Happy coding,
Samir

I created a simple, minimalist Prompt Chain library

Samir — Thu, 13 Feb 2025 02:52:43 +0000

Solving a Real Challenge in TasksForge.ai

During the development of TasksForge.ai, I encountered a key challenge: managing complex interactions between prompts that generate and elaborate projects and their tasks. I needed a seamless way to chain prompts together, ensuring that each output could intelligently guide the next step in the workflow. After exploring available solutions, I realized that existing libraries were either too complex, too rigid, or lacked the flexibility I needed.

So, I built my own solution: tasks_prompts_chain.

What is tasks_prompts_chain?

tasks_prompts_chain is a minimalist Python library designed for efficient and flexible LLM prompt chaining. Whether you’re working with AI-assisted task automation, chatbots, content generation, or any multi-step AI workflow, this library simplifies the process of structuring sequential prompts in a clean and reusable way.

💡

Core Features:

Simple API Define and chain prompts effortlessly.

Access each step prompt output easily access each output result prompt to either save to DB or just debug your prompting steps workflow.

Dynamic Inputs Pass variables dynamically between prompts.

Lightweight & Efficient No unnecessary dependencies, keeping it lean and fast.

You can check out the latest version of the library here: tasks_prompts_chain on PyPI.

Why Open Source?

I strongly believe in the power of open-source collaboration. By making tasks_prompts_chain publicly available, I hope to contribute to the AI development community while also gaining valuable feedback from other developers who face similar challenges. Open-source projects thrive on shared knowledge, and I’m excited to see how others might build upon and improve this tool.

A Glimpse into TasksForge.ai

This project is more than just a library; it’s part of a bigger vision. TasksForge.ai is a SaaS platform designed to streamline AI-assisted project management and task generation. By leveraging AI-driven workflows and automation, it empowers developers, entrepreneurs, and teams to work smarter and faster.

🛠 With TasksForge.ai, you can:

Project Insights: To truly understand a project, you need the right insights. This platform helps by providing customizable options to highlight the key features of your project.
Focus on specific aspects, such as performance, scalability, or user experience.
Offer actionable recommendations tailored to your needs.
Export to your favorite project management app: Seamlessly export your elaborated projects to your GitHub Projects account or Atlassian account.

The generated tasks can help you kickstart your idea with confidence and integrate easily into your existing workflow.

tasks_prompts_chain is just one of the many building blocks that power this ecosystem, helping ensure smooth, logical, and structured interactions between AI-driven workflows.

What’s Next?

🚀 A stable release is now available on the official Python Package Index (PyPI). I’m actively working on making the library more LLM SDK-agnostic—while it currently works seamlessly with OpenAI’s SDK, future updates will enhance its compatibility with other providers. If you’re interested in AI-driven task automation or prompt chaining, I’d love for you to try it out and share your feedback!

How You Can Get Involved:

✅ Try out tasks_prompts_chain and contribute to its development.

✅ Test and use TasksForge.ai and let me know if the project's generation meets your expectations.

✅ Share your thoughts—let’s build something great together!

Stay tuned for more updates, and let’s shape the future of AI-powered workflows! 🚀

Simplifying Project Management with AI-Powered Task Generation

Samir — Sun, 22 Dec 2024 23:44:09 +0000

Managing projects in the fast-paced world of software development can be challenging. As a developer, I understand the need for tools that help streamline workflows and make planning more manageable. That’s why I created this platform – a simple yet effective solution built with FastAPI and Next.js, using AI to make project management easier and more efficient.

What is This Platform?

TasksForge platform is designed to help bridge the gap between a rough idea and a detailed project plan. TasksForge leverages the power of Cerebras AI inference platform to deliver cutting-edge capabilities to our users. By integrating Cerebras light-speed AI inference, the platform utilizes Llama 3.1 70B to bootstrap the management of your IT project. By leveraging advanced AI models, it takes brief project descriptions and turns them into actionable task lists. Whether planning software design, mapping out web app features, or tackling complex projects, this tool is here to lend a hand.

Key Features of the Platform

AI-Powered Task Generation: One of the platform’s main features is its ability to create detailed task lists from short project descriptions. With it, you can:

Quickly generate a to-do list for your software design process.

Plan out features for your next web application.

Save time and focus on what matters most, while the AI handles the initial planning.

Project Insights: To truly understand a project, you need the right insights. This platform helps by providing customizable options to:
Highlight the key features of your project.
Focus on specific aspects, such as performance, scalability, or user experience.
Offer actionable recommendations tailored to your needs.
Export to GitHub Projects: Seamlessly export your elaborated projects to your GitHub Projects account. The generated tasks can help you kickstart your idea with confidence and integrate easily into your existing workflow.

Why I Chose FastAPI and Next.js

For the backend, I opted for FastAPI due to its speed and ability to handle APIs efficiently. On the frontend, Next.js was a natural choice for its interactive and dynamic user interface capabilities. Together, these frameworks provide the stability and performance needed to create a reliable application.

How It Works

TasksForge platform is built with a focus on reliability and efficiency, leveraging cutting-edge technologies to deliver an exceptional user experience:

Frontend with Next.js: Handles user interaction and provides a dynamic, responsive interface.

Backend with FastAPI: Powers the API endpoints, ensuring fast and secure data processing.

PostgreSQL Database: Stores generated projects and tasks in a structured and easily accessible format.

Integration with Cerebras AI: Sends API calls to Cerebras to query the Llama 3.1 70B model, enabling precise and powerful task generation, the used prompt.

GitHub GraphQL API: Facilitates seamless export of projects and tasks to your GitHub Projects account, allowing for effortless integration into your development workflow.

Input: Describe your project in a few words. For example, “A platform with real-time chat, analytics, and user authentication.”

Processing: The AI analyzes your input and generates detailed insights and task lists.

Output: You receive a clear roadmap, including milestones, task dependencies, and estimated timeframes.

Export: Export the project and its tasks directly to your GitHub Projects account for seamless integration into your development workflow.

Integration with Cerebras AI: Task Generation with Lama-3.3-70B

Our platform, TasksForge, integrates seamlessly with Cerebras AI, leveraging its powerful hardware to query the Llama 3.1 70B model via API calls. This integration enables highly precise and powerful task generation, helping users refine their project ideas with the assistance of an advanced language model.

To ensure users can only utilize the platform for generating project insights, we have implemented a structured approach to prompt design. The process begins with a system prompt that securely controls and limits the scope of queries to project-related tasks. This system prompts acts as a safeguard, preventing the model from being used for unintended purposes, and ensures the platform is used solely for generating actionable insights.

The user's input is integrated into the prompt as part of a user-specific project description entry. Once the project description is provided, a user prompt is generated to specify the desired template for the output. The model will then generate responses following a predefined structure that suits the user's project needs. This template prompting technique not only enhances the relevance of the output but also ensures that responses are aligned with the intended project scope.

The combination of these techniques the secure system prompt, user project description, and template-driven output, results in a dynamic yet controlled interaction with the LLM, enabling precise, predictable format, and actionable insights for every project.

Benefits for Project Managers, Developers, and Freelancers

For Project Managers: Understand project scope, organize tasks, and communicate plans effectively.

For Developers: Start coding sooner with a clear plan, reducing the chances of miscommunication.

For Freelancers: Present well-documented and organized projects to clients, ensuring clear communication and professional delivery of project plans.

A Tool to Support Your Workflow

TasksForge platform isn’t trying to replace your expertise; it’s here to support you. Whether you’re working on a personal project or collaborating with a team, it’s designed to make things simpler and more efficient.

Roadmap

1: Advanced Prompt Engineering for Task Generation: Improve prompt sophistication to ensure tasks generated align with structured software development methodologies. Integrate UML software design principles, particularly focusing on sequence diagrams, use cases, and user stories, to visually represent task dependencies and processes, this way we will have well-generated documentation at the biggin of the project.
2: Integration with Project Management Platforms: Enhance the platform by integrating with popular project management tools, beginning with Altisan. Future integrations with other tools such as Trello, or Asana will also be considered to offer flexibility for various project teams.

Interested in Trying It Out?

If you’re curious to see how this platform can fit into your workflow, give it a try at TasksForge. I’d love to hear your feedback and suggestions for improvement. Together, we can continue refining this tool to make it even more helpful.