DEV Community: AME - English for Tech People

What I learned while putting together my IDP (Individual Development Plan)

Karina Pereira — Thu, 18 Dec 2025 10:38:04 +0000

When I saw for the first time the acronym IDP (Individual Development Plan), I didn’t know what it was or how to create one. In the talk with my Tech Leader, we agreed that a topic could involve areas for improvement that I myself identified. However, Looking at my list of knowledge that I wanted to develop, I felt lost where to start and which area I should focus on first.

Definition

Based on these reflection, I defined my initial objectives:

1 - To improve my technical skills

2 - To document the entire project in English

Defining the subject wasn’t simple, because I tried not only considering my development, but how the IDP could add value to the company. It would be something useful, something I could apply in my daily life, and something that would help me making more informed architectural decisions in the future.

I thought: working as Full-Stack is impossible to know everything, but dominating principles of architecture makes all the difference, independently of the technology stack used.

So, I chose to study and apply SOLID (Single Responsibility, Open–Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion principles) in practice.

Based on these motivations I identified one more objective:

3 - To be a developer capable of applying best practices from the idealization step of a project.

My main motivation for choosing this subject came from my own experience. Many projects that I worked, I didn't have a mentor and learned by making mistakes, delivering the best I could in the shortest time possible.

Understanding SOLID better, would help me developing more organized and scalable systems, this directly impacts the quality of my work.

Planning

I organized a list of stacks and practices that I would love to apply:

1 - Laravel, using Eloquent, which is already part of my routine. To focus only on the concept and architecture rather than reinventing already established functionalities.
2 - Vue.js with Composition API
3 - ESLint and Prettier, ensuring that the code follows the standards without triggering errors in the IDE extensions.
4 - I was unsure whether to use Service Layer or Repository Pattern, I chose Service Layer, better explained in the details below.

Not everything I defined at the beginning was delivered, such as authentication, CORS (Cross-Origin Resource Sharing), deployment, and git hooks. I plan to do this level of implementation at another time. I focused only on best practices and architecture.

With that, I had the subject of the project: A map of urban legends, where I apply best practices, refine my skills in Laravel and Vue.js, and learn more about SOLID principles.

Practice

Why the Composition API?

I started with Vue.js using the Options API, but in some projects, I realized that the complexity grew along with the file size. I started working with the Composition API on ongoing projects and really enjoyed the experience, as it facilitates reusage and organization.

Applying SOLID principles to the front-end isn't so obvious, but I focused on separating responsibilities and making the code reusable.

I understood that the components should only handle UI

I created a src/api/ folder containing:

connect.js → responsible for configuring the connection to the API
legend.js → responsible for querying the API endpoints

Each file has a single responsibility.

The components do not depend on Axios, but only on the functions implemented inside legend.js.

For example, if I replace Axios for GraphQL, nothing in the component needs to be changed.

With this structure, the UrbanLegendMap.vue component only needs to handle UI (Leaflet), only consumes domain functions, and does not load HTTP logic inside of it.

Why the Service Layer?

In projects, it's very difficult to change the ORM, so implementing the Repository Pattern would only add an unnecessary layer and reproduce old habits. I understood that Repositories would perform a role that Eloquent already does. There would be no gain.

Therefore, the Service Layer makes business decisions, handles approaches, and deals with any reusable logic, becoming responsible for the business rules.

I understood that each class only needs one reason to be changed

The controller of the project was only responsible for receiving the request, calling the service interface, and returning an HTTP response, for example:

public function store(StoreUrbanLegendRequest $request)
{
    $legend = $this->service->create($request->validated());
    return (new UrbanLegendResource($legend))
        ->response()
        ->setStatusCode(Response::HTTP_CREATED);
}

No validation logic or business rules should exist in the Controller.

Inside the project, each time a new legend is created, a slug is generated to be accessed via URL.

This responsibility was assigned to the Model.

Therefore:

Validations are handled by Form Requests.
Business rules are handled by the Service.
Slug generation, UUIDs, and relationships are handled by the Model.

This kept each part of the system with well-defined responsibilities.

I understood that a structure doesn't need to be altered, but it should always be open for extension.

The controller only knows the service's interface, it doesn't depend on the service's implementation. If it's necessary to migrate the service's implementation to an external API, for example, then you just need to create another service that implements the same interface.

Nothing in the controller needs to change, and the service and controller depend on the same logical interface.

I understood that testing features can be beneficial

I usually only test the service or use the case of the application, but since I was dealing with a very well-structured project, I opted to create tests in two ways: feature tests and unit tests.

With feature tests, I can test the complete flow: route + middleware + request + service + model + resource, for example:

public function test_validates_required_fields_and_returns_422(): void
{
        User::factory()->create();

        $res = $this->withHeaders([
            'Authorization' => 'Bearer ' . $this->token,
        ])->postJson('/api/legend', $this->payload([
            'title' => '', 
        ]));

        $res->assertStatus(422)
            ->assertJsonValidationErrors(['title']);
}

This doesn't mean I'll always test features, but since my front-end depends exclusively on the external API, I thought it was important to have this test to verify if the response was in accordance with HTTP principles, and it also helped me writing the documentation.

Unit tests validated the business rule in isolation, for example:

public function test_list_returns_filtered_legends(): void
{
    $this->service->create($this->payload([
        'title' => 'Lenda - Brasília',
        'city'  => 'Brasília',
    ]));

    $this->service->create($this->payload([
        'title' => 'Lenda - Florianópolis',
        'city'  => 'Florianópolis',
    ]));

    $results = $this->service->list(['city' => 'Brasília']);

    $this->assertCount(1, $results);
    $this->assertEquals('Brasília', $results->first()->city);
}

I understood that this IDP changed my way of thinking

Throughout this IDP, my first and main objective was to improve my technical knowledge. I sought to understand each step and each implementation and to understand the reasoning behind each line. I consulted many articles to understand not only the theory but also to have practical examples.

By creating a project applying SOLID principles in practice, I understood that each architectural decision impacts the rest of the system. It's much better to have code that does what it's supposed to with an easily maintainable architecture.

This study wasn't just technical; it also changed my way of thinking. Currently, before writing code, I reflect on:

Who is responsible for this?
Does this class have a single reason to change?
Are there any unnecessary methods or functions?
Can it be extended without breaking?
Will I have a headache if I need to perform maintenance?

These questions have become part of my daily routine. That's exactly what I was looking for when I chose SOLID as my main topic: to learn something that wasn't just applicable to the IDP, but that could accompany my professional life from now on.

Although not all planned items were completed (authentication), I consider the IDP successful. The process brought me technical maturity and a much more solid understanding of how to structure a project, from idealization onwards, because I didn't just learn a technology, but I learned to think about architecture intentionally.

I learned that good practices don't depend on the stack, but on conscious decisions

And this evolution doesn't end here.

Link of project: https://github.com/kapcruz/urbanlegendmaps

Referencies:

SOLID4Noobs

O que é SOLID: O guia completo para você entender os 5 princípios da POO

Service Layer in Laravel — use it!

Create beautiful REST API docs authored in Markdown

From Front-end to Back-end: Understanding Databases Step

Larissa Dantier — Fri, 21 Feb 2025 11:30:00 +0000

Hello everyone! I'm here again for continue with an articles :), it's been a while since the last post, I ended up getting a bit busy but we came back. Let's go talk about Databases (The beginning of everything).

Understanding database

Basically, Database is an organized collection that help us a manage a large volum of data.

Helps manage the volum of data and information;
Allow quickly access to data;
Easy data recovery;

Collection: grouping of data organized and managed together.

Why use `databases`?

Databases play a crucial role in the efficient management of information in various sections. It offer a range of benefits.

Benefit	Description
Organization	`Data` is stored in a logical way, structure and allows for more efficient management and reduces redundancy
Easy Acces	With an efficient query it's possible to retrieve specific information in miliseconds, optimizing time and resources
Escability	`Database` are designed for handle with crescent volum of information, support from small operations to millions of users simultaneously

In addition to these benefits, they also promote data integrity and security. In increasingly data-driven world, a more efficient information management capacity is essential for the success of any organization.

📝 Example:
Hospitals use databases for patients' medical records, follow-ups, histories, notes and invoices.

Store use databases for products, invoices, amount, categories and others.

Key components of a `database`

We have some components for some fundamental elements that work in collections to store, organize and manage data, let's continue!

Name	Description
Table	`Tables` are the main units in a `database`, work in a similar way to spreadsheets. They are made up for `rows` and `columns`, which organize the data in a structured way
Rows	Each `row` represents a unit of log data. Contain specific information about an entity or item.
Column	The `columns` defines an attribute or property of stored data. Each `column` in a `table` represents a specific category of information, such as name, age or address

We've seen some very important points about Databases and how they work. The next article let's continue talking about databases yet :D.

Next Topics

Databases Types
- Relational
- Non-Relational
Differences of Relational vs Non-Relational
Primary Keys 🔑
Foreign Keys 😶‍🌫️

Thank you for reading this far!

Feel free to recommend articles, channels and so on of Back-end, I appreciate it 😎.

Starting my Back-end Journey (1/?)

Larissa Dantier — Wed, 05 Feb 2025 02:07:23 +0000

Hello, everyone! I'm Larissa and Front-end Developer, I have 5-6 years of professional experience and I started to see the need for learn back-end concepts in order to evolve my hard skills (Back-end is my achilles heel 😅).

The purpose of this post is tell you my steps of what I doing and also practicing my writing in English.

My expections and objectives

Last month, I started studying on uphop.ai. Uphop is a plataform with any courses free, I search video or other plataforms, but I didn't understand it very well and all video I found used ORM (Object Relational Mapping) like Prisma, TypeORM and others.

I began to feel that I was just copying and pasting, just creating tables without really knowing why or how it works and their rules. I ended up finding on Reddit in community called r/SQL and I found the Uphop.

I thought why not start at the bottom, My Front-end Journey started the same way!

So, that's why I explored the course SQL for Beginners which also has AI to help with any doubts and has some very nice practical examples.

I using Obsidian for my studies and probably I will use some notes I writed, themes like Databases, SQL, Syntax with your commands and how use and more!

Initial Steps

Learn SQL, Database, PostgreSQL, ORM (At some point) and others;
- Introduction to Databases and SQL
- Basic Data Retrieval with SQL
- Data Manipulation with SQL
- Joining Tables and Basic SQL Data Types
- Data Manipulation with SQL
- Database Structure and Views

Next steps

Learn NodeJS, Fastify, NestJS, Prisma and others
- Start a basic project using all concepts learn of Databases without ORM yet
- Read the Prisma Documentation - ORM(I'm going to write an article just about the Prisma`) and make a new project with it.

This initial article is more for you understand my objectives, how I'm going to study and to get to know myself a bit.

Thank you for reading this far! And I hope to write more about this new journey for me!

Feel free to recommend articles, channels and so on of Back-end, I appreciate it 😎.

Building an Article Generator with LangChain and Llama3: An AI Developer's Journey

Jorge Gomes — Mon, 09 Dec 2024 21:08:22 +0000

Building an Article Generator with LangChain and Llama3: An AI Developer's Journey

As an AI developer, I often find myself looking for ways to make complex Large Language Model (LLM) interactions more manageable. LangChain caught my attention not only because of its growing popularity in the AI development community, but also because of its practical approach to solving common LLM integration challenges. The framework's reputation for transforming complex LLM operations into streamlined workflows intrigued me enough to put it to the test. I decided to build an article generation system that would combine LangChain's capabilities with the Llama3 model to create a tool with real-world applications.

Why LangChain Makes Sense

LangChain changes the way we interact with LLMs by providing a structured, intuitive approach to handling complex operations. Think of it as a well-designed development kit, with each component serving a specific purpose. Instead of juggling raw API calls and manually managing prompts, the framework provides a clean interface that feels natural from a developer's perspective. It's not just about simplifying the process, it's about making LLM applications more reliable and maintainable.

Key Components of LangChain

At its core, LangChain uses chains, sequences of operations that link together to create more complex behaviors. These chains do everything from formatting prompts to processing model responses. While the framework includes sophisticated systems for managing prompts and maintaining context across interactions, I'll focus mainly on the chain and prompt aspects for our article generator.

The Article Generator

For this project, I wanted to build something practical, a system that could generate customized articles based on specific parameters such as topic, length, tone, and target audience. The Llama3 model, accessed through Ollama, provided the right balance of performance and flexibility for this task.

Getting Started

The setup is straightforward:

First, I installed the necessary packages:

pip install langchain langchain-ollama requests

Then, I set up Ollama:
1. I downloaded and installed Ollama from https://ollama.com/blog/llama3
2. In a new terminal, I started the Ollama server:

ollama serve

I pulled the Llama3 model:

ollama pull llama3

The Ollama server must be running in its terminal while using the article generator. If it is closed, the generator won't be able to connect to the model.

Building the Core Components

Let's break down how each part of the system works:

Connection Managment

This simple check helps to avoid runtime errors by catching connection problems early. It is a reliable way to check the connection to the Ollama server:

def check_ollama_connection():
    """
    Check if Ollama server is running
    """
    try:
        requests.get('http://localhost:11434/api/tags')
        return True
    except requests.exceptions.ConnectionError:
        return False

Model Configuration

Model setup is critical for getting the right balance in our generated content:

llm = OllamaLLM(
    model="llama3",
    temperature=0.7,  # Balances creativity and consistency
    top_p=0.9,       # Helps with text diversity
    num_ctx=4096     # Sets the context window
)

These parameters represent the sweet spot I found after testing various combinations for article generation.

Temperature (0.7): Controls the randomness of the output. A lower value (like 0.3) would make the text more predictable, while a higher value (like 0.9) would make it more creative. 0.7 is a good balance.

Top_p (0.9): This parameter, also known as nucleus sampling, tells the model how many word options to consider. At 0.9, it looks at enough options to keep the text interesting while staying focused on the topic.

num_ctx(4096): The context window size, or how much text the model can work with at once. This gives enough room for both the input and a substantial article output, as it can handle roughly 3000-3500 words.

Prompt Engineering

The prompt template is where we define what we want from the model:

article_template = """
You are a professional content writer tasked with creating a comprehensive article.

Topic: {topic}

Writing Requirements:
1. Length: Approximately {word_count} words
2. Style: {tone} tone
3. Target Audience: {audience}
4. Format: Plain text without any markdown notation
5. Additional Details/Requirements: {extra_details}

Content Structure Guidelines:
- Start with an engaging introduction that hooks the reader
- Organize content into clear sections with descriptive headings (not numbered)
- Include relevant examples, statistics, or case studies when appropriate
- Provide practical insights and actionable takeaways
- End with a compelling conclusion that summarizes key points
- Ensure smooth transitions between paragraphs and sections

Writing Style Guidelines:
- Use clear, concise language appropriate for the target audience
- Avoid jargon unless necessary for the target audience
- Incorporate relevant examples and real-world applications
- Maintain an engaging and natural flow throughout the article
- Use active voice predominantly
- Include specific details and evidence to support main points
- Ensure proper paragraph breaks for readability

Additional Notes:
- Do not use any markdown formatting
- Keep paragraphs concise and focused
- Use proper spacing between sections
- If technical terms are used, provide brief explanations
- Include a brief overview of what will be covered at the start

Please write the article now:
"""

Generation Pipeline

One of the most elegant features of LangChain is its simple chain composition:

chain = prompt | llm

This single line creates a complete generation pipeline that handles prompt formatting, model interaction, and response processing.

Command Line Interface

To make the tool user-friendly, I implemented a command line interface:

def parse_arguments():
    """
    Parse command line arguments
    """
    parser = argparse.ArgumentParser(description='Generate an article using AI')

    parser.add_argument('--topic', 
                       type=str, 
                       required=True,
                       help='The topic of the article')

    parser.add_argument('--word-count', 
                       type=int, 
                       default=800,
                       help='Target word count (default: 800)')

    parser.add_argument('--tone', 
                       type=str, 
                       default='professional',
                       choices=['professional', 'casual', 'academic', 'informative', 'technical'],
                       help='Writing tone (default: professional)')

    parser.add_argument('--audience', 
                       type=str, 
                       default='general',
                       help='Target audience (default: general)')

    parser.add_argument('--extra-details', 
                       type=str, 
                       default='',
                       help='Additional requirements or details for the article')

    return parser.parse_args()

Practical Usage

The use of the generator is very simple: you run the code and pass the parameters.

Example #1

python main.py \
  --topic "Benefits of playing board games with friends" \
  --word-count 200 \
  --tone casual \
  --audience "Board games lovers" \
  --extra-details "Avoid markdown notation"

The generated article:

Article generated in 12.39 seconds:

The Joy of Board Games: Why Playing with Friends is a Game-Changer

As we navigate the ups and downs of life, it's easy to get caught up in our individual pursuits and lose sight of the importance of social connections. But what if I told you that playing board games with friends can be a powerful way to strengthen those bonds, boost your mood, and even improve your mental health?

Benefits for Your Brain

Playing board games requires strategy, problem-solving, and critical thinking – all valuable skills that can help keep our brains sharp as we age. In fact, studies have shown that engaging in mentally stimulating activities like playing board games can delay the onset of age-related cognitive decline by up to five years.

Social Benefits Galore

But it's not just about individual brain benefits – playing board games with friends can also have a profound impact on our social lives. For one, it provides a unique opportunity for social interaction and bonding. When we laugh, joke, and share in the excitement of competition or cooperation, we're building memories and strengthening relationships that will last a lifetime.

Reducing Stress and Anxiety

In today's fast-paced world, stress and anxiety can be overwhelming. And while there are many ways to manage these feelings, playing board games with friends can be a particularly effective way to unwind and de-stress. The simple act of focusing on the game, away from our daily worries, can provide a much-needed break and help us approach life's challenges with a clearer head.

Conclusion

So the next time you're looking for a fun and fulfilling way to spend time with friends, consider breaking out the board games! Not only will you be exercising your brain and building relationships, but you'll also be reducing stress and anxiety. And who knows – you might just discover a new favorite game or hobby along the way.

Example #2

python main.py \
  --topic "Building an AI Article Generator with LangChain" \
  --word-count 200 \
  --tone informative \
  --audience "Python developers" \
  --extra-details "It's for beginners."

The generated article:

Article generated in 20.99 seconds:

Building an AI Article Generator with LangChain: A Beginner's Guide

As a Python developer, you're likely familiar with the challenges of generating high-quality content quickly and efficiently. With the rise of artificial intelligence (AI) and natural language processing (NLP), it's become possible to create intelligent article generators that can produce engaging and informative content in no time. In this article, we'll explore how to build an AI article generator using LangChain, a popular open-source library for generating text.

What is LangChain?
LangChain is a Python library designed specifically for building language models and text generation applications. It's built on top of the powerful transformer architecture and provides a range of tools and features for creating custom language models and generators. With LangChain, you can train your own language model using a dataset of your choice and use it to generate high-quality text.

Getting Started with LangChain
To get started with LangChain, you'll need to install the library and import it into your Python environment. You can do this by running pip install langchain in your terminal or command prompt. Once installed, you can start building your AI article generator by defining a few key components:

* A dataset of text data that you want to use for training your language model
* A custom language model architecture that you want to train using the dataset
* A set of parameters and hyperparameters that you'll use to fine-tune your model

Training Your Language Model
To train your language model, you'll need to define a custom trainer class that will handle the training process. This class should include methods for loading your dataset, defining your model architecture, and optimizing your model's performance using a chosen loss function.

Using Your Trained Model to Generate Text
Once your language model is trained, you can use it to generate text by passing in some input prompts or text data. LangChain provides a range of pre-trained models that you can use for this purpose, including the popular T5 and BERT models.

Conclusion
Building an AI article generator with LangChain requires some programming expertise and knowledge of NLP concepts. However, with these skills and the right tools, you can create powerful language models that can generate high-quality text in no time. Whether you're a beginner or an experienced developer, LangChain provides a range of features and capabilities that make it easy to get started with building your own AI article generator.

Key Learnings

Throughout this project, I discovered several important insights about working with LangChain:

Performance Patterns: The first generation takes longer due to model loading, but subsequent runs are significantly faster.
Context Management: A 4096-token context window provides ample space for most articles while maintaining good performance.
Generation Parameters: Temperature (0.7) and top_p (0.9) settings provide an optimal balance between creativity and coherence.

Final Thoughts

Building this article generator demonstrated LangChain's practical value in AI development. It handles the complexities of LLM interactions while giving developers the freedom to focus on building useful features. The framework strikes a balance between abstraction and control, making it easier to create reliable AI-powered applications.

For dear colleagues in the area or sole enthusiasts, I’m confident that LangChain provides all the necessary meaning for development, and the best part is: it’s not a trade-off with flexibility. Thinking that the field of AI tools is exponentially growing, frameworks like LangChain will become more valuable for building practical, production-ready applications.

The LangChain logo of a parrot and a chain has a clever meaning behind it. The parrot refers to how LLMs are sometimes called “stochastic parrots” because they repeat and rework human language. The chain part is a playful reference to how the framework helps to “chain” language model "parrots" into useful applications.

Regex in VSCode: My favorite hacks

Karina Pereira — Fri, 29 Nov 2024 04:00:06 +0000

Recently, I needed to implement a gradual feature rollout. I had a spreadsheet with a list of 300 company IDs in the first column, which would be part of this phased release.

My task was to take each ID individually and insert it into an update query to execute directly in the database.

At first, I considered multiple different methods to make it. Then I remembered of VSCode combination with Regular Expressions, a technique I had heard about but never actually tried. This situation was the perfect opportunity to test it out.

My idea with this article is to show you how combining VSCode with regular expressions can assist you.

Reasons To Use

One of the most common uses is finding and replacing text, removing duplicates, and making adjustments across multiple files. You can see other applications in the following documentation: https://learn.microsoft.com/en-us/visualstudio/ide/using-regular-expressions-in-visual-studio?view=vs-2022

I will focus on the methods I have used that have helped me.

How to use?

To Enable the regular expressions in the function finding, press:

Command + F (MacOS) or Ctrl + F (Windows, Linux)
Option + Command + F (⌥⌘F) or Ctrl + H (Windows, Linux)

This command will open the dialog box with Toggle Replace enabled:

After this, you can check the option to "Use the Regular Expression”, usually represented by a .* icon, with the command:

Option + Command + R (⌥⌘R) or Alt+E (Windows, Linux)

My Favorite Cheats

Find and Replace

My first favorite cheats is to separate numbers with commas and quotes:

Search: (\d+)

Replace: "$1”, (or no quotes $1,)

This will wrap the number in quotes and add a comma after it.

Transform multiples line into one:

Search: \n
Replace: Use a space or nothing (depending on your preference).

Comment specific search across multiple files

Replace: // $0

Find instances for classes

To find instances where a class is being instantiated, use the following pattern:

Search: new\s+User\s*\(

How did I find these regular expressions?

I usually search for them after testing on regex101.com or by Googling examples.
Try exploring and adapting these techniques to your workflow.

Regex can work like magic!

How to Run FLUX1 for Free: A Step-by-Step Guide

Felippe Chemello — Mon, 09 Sep 2024 17:22:18 +0000

Flux.1 is the newest text-to-image model in the market, brought to us by Black Forest Labs. It is a state-of-the-art model that can generate high-quality images from text descriptions handling complex descriptions and generating high-quality images with fine details.

Who is behind Flux.1?

Flux.1 is developed by Black Forest Labs, a company created by a group of ex employees from Stability AI.

How does it work?

Unlike other diffusion models, like Stable Diffusion that create images by gradually removing noise from a random start point, Flux.1 generates images using a technique called "flow matching" that takes a more direct approach, learning the exact transformations needed to convert noise into a realistic image. This allows to generate high-quality images faster and with less steps than common diffusion models.

Also, with this different approach, Flux.1 can handle images with text inside it, like the one below:

A photorealistic image of a modern, sleek laptop with a webpage open displaying the text "codestackme" in a clean, minimalist design. The laptop should be positioned on a white desk with soft lighting, highlighting the screen's glow and the subtle reflections on the metallic casing. The overall atmosphere should be professional and inviting, conveying a sense of innovation and technological advancement.

How to write a good prompt for Flux.1?

One of Flux.1’s standout features is its user-friendly prompting mechanism. The integration of CLIP (from OpenAI) and T5 (from GoogleAI) text encoders allows the model to interpret descriptions with a high degree of nuance. CLIP excels in aligning text with visual content, while T5 enhances the model's ability to process structured text inputs. Together, they enable Flux.1 to generate images that closely match the detailed prompts provided by users.

What types of models are there for Flux.1?

Flux.1 comes in three distinct versions: Schnell, Dev and Pro.

Schnell is the fastest model, optimized for speed and efficiency. It is allowed for commercial use, since was released under the Apache 2.0 license.
Dev provides a more flexible and experimental framework, it’s focused for developers and researches who want to fine-tune or customize certain features of the model. It was released with a non-commercial license.
Pro is the most advanced and resource-intensive version. It offers higher resolution outputs and can generate more complex images, however it is only available though the Black Forest Labs API.

How to use Flux.1 for free?

For those interested in exploring the capabilities of Flux.1 without financial commitment, using modal.com as a resource provider is a viable option. Modal.com offers a monthly compute power allowance of $30, which can support the generation of numerous images each month. You can learn more about their pricing and offerings at Modal.com Pricing.

This recommendation is not sponsored or endorsed by the platform.

To begin, you'll first need to create an account on modal.com by logging in using your GitHub credentials.

Next, you'll need to install the Modal CLI. Ensure that Python is installed on your computer. Once Python is set up, open your terminal and execute the command pip install modal. After the installation is complete, run modal setup to link the CLI with your Modal account.

Proceed by cloning this GitHub repository to your computer and navigate to the cloned directory.

For security, create a secret called flux.1-secret in your modal dashboard with an environment variable named API_KEY and assign it a random string.

Finally, deploy your service by running modal deploy app.py --name flux1 in your terminal. Upon successful deployment, modal will provide a URL for accessing the web service:

✓ Created objects.
├── 🔨 Created mount PythonPackage:app
├── 🔨 Created function Model.build.
├── 🔨 Created function Model.*.
├── 🔨 Created function Model._inference.
└── 🔨 Created web function Model.web_inference => <PUBLIC_URL>
✓ App deployed in 3.206s! 🎉

To use the service, make a GET request to the provided PUBLIC URL. Include the x-api-key you set earlier in the headers, and encode your prompt in the query parameters. You can also specify desired image dimensions through query parameters. Here’s an example of how to structure your request:

curl -H "x-api-key: <API_KEY>" <PUBLIC_URL>?width=<WIDTH>&height=<HEIGHT>&prompt=<PROMPT>

Understanding the Code

Let's dissect the app.py file, which is crucial for running our Flux.1 image generation service using modal's platform. Here's a breakdown of the setup and functionality:

import modal

image = modal.Image.debian_slim(python_version="3.10").apt_install(
    "libglib2.0-0", 
    "libsm6", 
    "libxrender1", 
    "libxext6", 
    "ffmpeg", 
    "libgl1",
    "git"
).pip_install(
    "git+https://github.com/huggingface/diffusers.git",
    "invisible_watermark",
    "transformers",
    "accelerate",
    "safetensors",
    "sentencepiece",
)

This block defines the Docker image for our application, specifying the OS, necessary libraries, and Python packages. This environment supports the execution of the Flux.1 model and associated utilities.

app = modal.App('flux1')

with image.imports():
    import os
    import io
    import torch
    from diffusers import FluxPipeline
    from fastapi import Response, Header

Here, we initialize our app and import necessary Python libraries within the context of our previously defined Docker image. These imports are essential for image processing and handling web requests.

@app.cls(gpu=modal.gpu.A100(), container_idle_timeout=15, image=image, timeout=120, secrets=[modal.Secret.from_name("flux.1-secret")])
class Model:
    @modal.build()
    def build(self):
        from huggingface_hub import snapshot_download

        snapshot_download("black-forest-labs/FLUX.1-schnell")

    @modal.enter()
    def enter(self):
        print("Loading model...")
        self.pipeline = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16).to('cuda')
        print("Model loaded!")

    def inference(self, prompt: str, width: int = 1440, height: int = 1440):
        print("Generating image...")
        image = self.pipeline(
            prompt, 
            output_type='pil', 
            width=width, 
            height=height, 
            num_inference_steps=8,
            generator=torch.Generator("cpu").manual_seed(
                torch.randint(0, 1000000, (1,)).item()
            )
        ).images[0]

        print("Image generated!")

        byte_stream = io.BytesIO()
        image.save(byte_stream, format="PNG")

        return byte_stream.getvalue()

    @modal.web_endpoint(docs=True)
    def web_inference(self, prompt: str, width: int = 1440, height: int = 1440, x_api_key: str = Header(None)):
        api_key = os.getenv("API_KEY")
        if x_api_key != api_key:
            return Response(content="Unauthorized", status_code=401)

        image = self.inference(prompt, width, height)
        return Response(content=image, media_type="image/png")

This section defines the main functionality of our service:

@modal.build(): Downloads the model when the application builds.
@modal.enter(): Loads the model into GPU memory the first time the service is invoked.
@modal.web_endpoint(): Serves as the web endpoint for our service using FastAPI.

If you just want to run it as a local service, you can add @modal.method() and define it as following inside the class.

        @modal.method()
    def _inference(self, prompt: str, width: int = 1440, height: int = 1440):
        return self.inference(prompt, width, height)

And outside it, define a local entry point

@app.local_entrypoint()
def main(prompt: str = "A beautiful sunset over the mountains"):
    image_bytes = Model()._inference.remote(prompt)

    with open("output.png", "wb") as f:
        f.write(image_bytes)

Local entry point will run locally on your machine calling the _inference method remotely, so you still using the modal’s service, without exposing it to the internet.

Conclusion

Flux.1 is not just another tech breakthrough - it's a game-changer for anyone who's ever dreamed of bringing their ideas to life visually. Imagine being able to describe a scene in words and watch as it materializes into a stunning, detailed image right before your eyes. That's the magic of Flux.1. It's like having a super-talented artist at your fingertips, ready to paint your thoughts with incredible precision. Whether you're an artist looking to speed up your creative process, a designer in need of quick visual concepts, or just someone who loves playing with new tech, Flux.1 opens up a world of possibilities. It's not about replacing human creativity - it's about enhancing it, making the journey from imagination to reality smoother and more exciting than ever before.

DEV Community: AME - English for Tech People

What I learned while putting together my IDP (Individual Development Plan)

Definition

Planning

Practice

Why the Composition API?

I understood that the components should only handle UI

Why the Service Layer?

I understood that each class only needs one reason to be changed

I understood that a structure doesn't need to be altered, but it should always be open for extension.

I understood that testing features can be beneficial

I understood that this IDP changed my way of thinking

I learned that good practices don't depend on the stack, but on conscious decisions

From Front-end to Back-end: Understanding Databases Step

Understanding database

Why use databases?

Key components of a database

Next Topics

Starting my Back-end Journey (1/?)

My expections and objectives

Initial Steps

Next steps

Building an Article Generator with LangChain and Llama3: An AI Developer's Journey

Building an Article Generator with LangChain and Llama3: An AI Developer's Journey

Why LangChain Makes Sense

Key Components of LangChain

The Article Generator

Getting Started

Building the Core Components

Connection Managment

Model Configuration

Prompt Engineering

Generation Pipeline

Command Line Interface

Practical Usage

Example #1

Example #2

Key Learnings

Final Thoughts

Regex in VSCode: My favorite hacks

Reasons To Use

How to use?

My Favorite Cheats

Find and Replace

Transform multiples line into one:

Comment specific search across multiple files

Find instances for classes

How did I find these regular expressions?

How to Run FLUX1 for Free: A Step-by-Step Guide

Who is behind Flux.1?

How does it work?

How to write a good prompt for Flux.1?

What types of models are there for Flux.1?

How to use Flux.1 for free?

Understanding the Code

Conclusion

Why use `databases`?

Key components of a `database`