Accelerating Django Projects: Automation with LangChain

In our daily work with Django, a popular framework for creating web applications, we often face the task of developing new applications quickly. Vital as it is, such a process can be tedious and time-consuming. Fortunately, with the new AI capabilities, it can be automated and save you precious time. How to achieve it?

While deploying Django apps, the initial phase of discussions with the client that allows us to gather all the necessary guidelines, which we then transform into specific tasks (tickets), is a creative and exciting process. But there is another side to the coin - the implementation of all the scaffolding tasks often comes down to repetitive, tedious work.

How to automate this process, so that you can focus on what’s most important?

We used LangChain to address the typical challenges while fast-starting Django applications. Not only did we alleviate repetitiveness and time consumption, but also reduced:

• Risk of errors
• Suboptimal application architecture
• Limitations on innovation
• Developer dissatisfaction

It’s proved a gamechanger for our team, and I definitely recommend your team give it a try. Go to our GitHub for the full repository.

The challenges of developing Django applications

Manually creating Django applications, although offering developers full control over the project, brings significant challenges.

One of the main problems is the repetitiveness and time-consuming nature of some tasks.

Typical application components, such as models, views, forms, or admin configuration files, require similar coding patterns across different projects.

This repetitive nature of work can not only become tedious for programmers but also consume valuable time that could be better spent on innovation and creative aspects of the project.

Furthermore, the manual approach to coding increases the risk of introducing errors. From simple typos to more complex mistakes in application logic, each error requires time to identify and correct, further delaying the development process.

In a rush to meet deadlines, programmers may also not have the opportunity to thoroughly consider the application architecture or apply best practices, which can result in difficulties in later maintenance and scaling of the project.

Therefore, the manual process of creating Django applications, while necessary in some aspects, poses significant challenges in terms of efficiency, quality, and project costs.

Focusing on repetitive and monotonous tasks limits not only the possibility of exploring new technologies and solutions but can also affect the satisfaction and motivation of developers.

Automation of the initial stages of application development thus becomes not only desirable but in many cases necessary to meet the modern requirements of quickly delivering valuable and effective software solutions.

Here, LangChain enters the stage.

How to automate Django development with LangChain?

The process of automating Django application creation in our company uses advanced LangChain technologies, enriched with artificial intelligence thanks to ChatOpenAI and RAG (Retrieval-Augmented Generation).

Let's analyze the steps of this process, indicating the relevant code fragments and their significance.

1. Loading projects into the vectorstore

This step initiates the process by loading existing Django projects into the vectorstore using OpenAI embeddings, allowing for efficient searching and matching of content.

```python

vectorstore = FAISS.from_texts(get_django_files_contents(), embedding=OpenAIEmbeddings())

```

In the above example, get_django_files_contents function reads Python files (except migrations) recursively from the provided directory and returns them as a list of strings. It loads a file as a string appending to the beginning one line with filename e.g.:

"""

# <filepath>

<file content>

"""

```

2. Creating a retriever from vectorstore

The retriever uses previously loaded projects to search for documents most related to the current task, thereby facilitating the finding of useful patterns and solutions.

```python

retriever = vectorstore.as_retriever(search_kwargs={'k': 2})

```

3. Transforming the task content into a prompt for ChatOpenAI

In this step, the task content is transformed into a prompt that will be passed to the ChatOpenAI model, initiating code generation.

```python

standalone_user_story = {

"standalone_user_story": final_inputs | DJANGO_DEVELOPER_PROMPT | ChatOpenAI() | StrOutputParser(),

}

```

The prompt I used is meant for creating context for ChatGPT so it behaves like a Django developer, and to rephrase the input user story and the text that user puts into a standalone user_story.

""" You are python Django Senior Developer.\n
You know how to write a code in Django files.\n
Follow up user_story, rephrase the follow up user_story to be a standalone user_story, in its original language.\n
Follow Up Input: {user_story}\n
Standalone user_story:"""

4. Using the retriever to find relevant documents

In this process, not directly shown in the code, the retriever searches for documents that can serve as context or inspiration for the generated code.

5. Generating code for `apps.py` and `models.py` using ChatOpenAI

Using ChatOpenAI with a properly prepared prompt, we generate code for `apps.py` and `models.py`, key files of every Django application.

```python

generate_first_pair = {

"first_pair": final_inputs | GENERATE_APPS_AND_MODELS_FILES_PROMPT | ChatOpenAI() | _create_files,

}

```

The prompt instructs ChatGPT to, first of all, put converted Django files from reference projects into a prompt in {context} variable, and then to create new files according to user story based on those files. As a result, it will return a prompt with content of apps.py and models.py files, which later on we save in those files.

""" \nThis is how to write an Python Django apps:
{context}\ns
\n
Remember: always give a code in "```python" markdown.\n
Code need to be in english - always!\n
In "```python" markdown always start with line "# <path/to/file.py>" line.\n
Root folder of application is "app", all other app folders you can named by your own.\n
Create a two files per each app: "apps.py" and "models.py" django app files based only on the following User Story:\n
\n
User Story: \n{user_story} """

6. Saving the generated code to disk files

The `_create_files` function is called directly within the chain and is responsible for saving the generated code to disk files, providing constant access to the AI's work results.

7. Generating additional files `admin.py` and `filters.py`

Based on the already generated `apps.py` and `models.py` files, the system proceeds to the next stage, where `admin.py` and `filters.py` files are generated, forming a further part of the application structure.

```python

generate_second_pair = {

"second_pair": _print | GENERATE_ADMIN_AND_FILTER_FILES_PROMPT | ChatOpenAI() | _create_files,

}

```

The prompt is almost the same instruction for ChatGPT as before but meant to create admin.py and filters.py files based on already created app.py and models.py files.

""" \nGiven the existing Django app files `apps.py` and `models.py`, generate the corresponding `admin.py` and `filters.py` files.
\n
Every content file have information about path of the file, at the begin, example: # ../this/is/file/path.py \n
Here are apps.py and models.py content: \n
{first_pair}
\n
Generate admin.py and filters.py files for all classes in all models.py files:"""

8. Iteration and optimization of results

After generating the code, the developer has the opportunity to verify it and, if necessary, run the process again with improved prompts or make manual corrections to better adapt the code to project requirements.

Thanks to the integrated use of LangChain, ChatOpenAI, and RAG technology, the process of creating Django applications is not only faster and more efficient but also opens up new possibilities for customization and optimization of code, significantly accelerating project development and reducing their costs.

The benefits of using LangChain for developing Django apps

As you can see, implementing LangChain tools, in combination with technologies such as ChatOpenAI and RAG (Retrieval-Augmented Generation) into the Django application creation process can bring significant benefits to your company and your clients.

By transforming the traditional, often repetitive and time-consuming process into a fast, automated operation, we achieved several key gains:

• Drastic reduction in development time
• Lower development costs
• Improved code quality
• Increased developer satisfaction
• Flexibility and iterativeness

Let’s have a closer look at those.

Drastic reduction in development time

Automation of generating basic components of applications, such as `apps.py`, `models.py`, `admin.py`, and `filters.py`, reduces the time needed for these tasks from several hours to just a few seconds. This allows programmers to focus on more complex and creative aspects of projects.

Reduction in development costs

Automating the initial stages of application creation significantly reduces costs associated with manual coding. Shortening the time programmers spend on monotonous tasks means that these resources can be better utilized in other areas, translating into lower overall project costs.

Improvement in code quality

Using AI models to generate code ensures its high quality and consistency with best practices. Each generated code fragment is the result of machine learning from large data sets, minimizing the risk of errors and providing optimal solutions.

Increased satisfaction among programmers

Automation of tedious tasks allows developers to focus on more satisfying work aspects, such as architecture design, optimization, or innovation. This contributes to better team morale and reduces the risk of professional burnout.

Flexibility and iterativity in the development process

Automation does not mean relinquishing control over the process. On the contrary, it provides the opportunity for rapid iteration and adaptation of projects based on current requirements. Programmers can easily modify guidelines and regenerate parts of the application, promoting continuous improvement and adjustment of the product to changing needs.

Summary: Applying LangChain in Django app development is highly recommended

Introducing LangChain tools into your Django application creation process can significantly transform how you approach software development. By automating routine tasks, not only can you increase efficiency and reduce costs, but also pave the way for new innovative opportunities that can further strengthen your offer for the clients.

The use of LangChain tools in the Django application creation process can be a milestone in efficient and economical software development. It transforms routine work into a quick, automated process, allowing programmers to focus on more advanced project aspects and deliver valuable solutions in less time. It’s clearly a win-win for everyone involved.