The post has been translated automatically. Original language: Russian Russian
"Wow!" or why is this the first local AI agent that does everything by itself
«Вау!» или почему это первый локальный AI-агент, который делает всё сам
Imagine: you enter a single description of the task, and the artificial intelligence completely writes the necessary code itself, saves it to a file, automatically installs the necessary dependencies (if required) and immediately runs the resulting script!And all this in a local environment, without sending your code to someone else's cloud. If an error occurs, the AI agent can figure out what went wrong on its own and adjust the query to the model in an attempt to fix the problem. It's really impressive!
Like any experimental technology, this AI agent is far from ideal and can make mistakes.:
- There may be false positives or situations when the agent will not be able to correct the error correctly and will endlessly reformulate the request.
- The code that the agent generates may sometimes not work as you expect. Sometimes there may be logical errors or inconsistencies with your environment.
It is important to understand that this is still a beta version and does not guarantee 100% stable operation. In some cases, you will have to manually intervene and adjust the result. However, even now it demonstrates how far development automation has progressed.
- Python 3.8+Make sure you have a modern version of Python installed. You can check with the command: python --version
2. Ollama LLM server (or another local/remote LLM server option)
- In the example, the code is configured on the server at http://localhost:11434/v1 .
- If you are using Ollama, run the Ollama server locally. Make sure that it accepts requests on the correct port (default is 11434).
- If you want to use another LLM service, replace the address. http://localhost:11434/v1 to the appropriate one.
3. qwen_agent (or a similar package for interacting with your LLM)
- Install via PyPI: pip install qwen-agent
Save this code to a file, for example, agent.py:
import json
import os
import subprocess
from qwen_agent.llm import get_chat_model
def reformulate_request_agent(user_request, error_description=None):
"""
Function for reformulating the request to the model.
Accepts:
- user_request: the source text of the request from the user.
- error_description: Error message if the code did not run.
Returns:
- Reformulated text of the request for re-generation of the code.
"""
llm = get_chat_model({
'model': 'qwen2.5-coder:14b', # Model name
'model_server': 'http://localhost:11434/v1 ', # The address of your Ollama or other LLM server
'api_key': 'EMPTY', # Specify the key if necessary
})
# Forming a message for the system
base_message = user_request
if error_description:
base_message +=f"An error message was received: {error_description}."
messages = [
{
'role': 'system',
'content': (
"You are an assistant that reformulates user requests to ensure they are suitable "
"for generating Python code. Your reformulated request should be clear and precise."
)
},
{'role': 'user', 'content': base_message}
]
# Here, the model generates a response (a reformulated query).
responses = []
for responses in llm.chat(messages=messages, stream=True):
pass
# Returning the final reformulation
return responses[0]['content']
def save_and_run_code(code, name_file, dependencies=None):
"""
A function that:
1. Saves the transferred Python code to a file.
2. Installs dependencies (if specified).
3. Runs the created file and returns the result (or error).
:param code: A string with Python code.
:param name_file: The name of the file to save the code.
:param dependencies: A string with a list of dependencies (separated by a space).
:return: Dictionary format {"success": bool, "output" or "error":str}
"""
# Converting the code to the desired format (escape characters '\n' or '\t' suddenly arrived)
formatted_code = code.replace("\\n", "\n").replace("\\t", "\t")
# 1. Save the code to a file
with open(name_file, "w", encoding="utf-8") as file:
file.write(formatted_code)
print(f"Code saved to file: {name_file}")
# 2. Installing dependencies (if any)
if dependencies:
print(f"Installing dependencies: {dependencies}")
try:
# pip install <dependencies>
subprocess.run(["pip", "install"] + dependencies.split(), check=True, capture_output=True, text=True)
print("Dependencies have been successfully installed.")
except subprocess.CalledProcessError as e:
error_message = f"Error installing dependencies: {e.stderr}"
print(error_message)
return {"success": False, "error": error_message}
#3. Running
the try code:
result = subprocess.run(["python", name_file], capture_output=True, text=True)
if result.returncode != 0:
# If the code returned with an error (not 0)
return {"success": False, "error": result.stderr}
# If everything is OK, we return the result
print(f"Result of {name_file} file execution:\n{result.stdout}")
return {"success": True, "output": result.stdout}
except Exception as e:
print(f"Error when starting the file {name_file}: {e}")
return {"success": False, "error": str(e)}
def reformulate_request(error_description):
"""
The simplest function that generates a new request based on the error.
"""
return f"Fix the error: {error_description}"
def test():
"""
The main function that shows an example of the agent's work.
Steps:
1. We receive a request from the user (task description).
2. We form messages for LLM, where we indicate that we want to receive ready-made Python code.
3. The model tries to generate the code by calling the save_and_run_code function.
4. If an error occurs, the user is prompted for an updated query (or automatically reformulated).
5. Repeat until the correct result is obtained.
Important: Since the agent is still in beta, sometimes there may be cyclical attempts to fix the error.
If you see that he can't figure it out for too long, abort the execution and adjust the code manually.
"""
# Connecting the model (specifying the server and the model name)
llm = get_chat_model({
'model': 'qwen2.5-coder:14b', # Model name
'model_server': 'http://localhost:11434/v1 ', # Address of Ollama or another LLM server
'api_key': 'EMPTY',
})
# Request example (instead of input, you can simply specify a string)
req_user = str(input("Enter your code description: "))
req_user2 = req_user
while True:
# We print the request to see what we are sending
print("Current request to the model:", req_user)
# Forming messages for LLM
messages = [
{
'role': 'system',
'content': (
"You are an assistant that generates Python code based on user descriptions. "
"In addition to generating the code, you are responsible for providing the file name "
"where the code will be saved and a list of dependencies required to execute the code. "
"Ensure the output is executable and properly formatted."
)
},
{'role': 'user', 'content': req_user}
]
# We describe the function that the model can call (function call)
functions = [{
'name': 'save_and_run_code',
'description': 'Generates Python code, saves it to a specified file, installs dependencies, and executes it.',
'parameters': {
'type': 'object',
'properties': {
'code': {
'type': 'string',
'description': 'Python code',
},
'name_file': {
'type': 'string',
'description': 'file name for saving the code',
},
'dependencies': {
'type': 'string',
'description': 'A space-separated list of dependencies to install before running the code',
},
},
'required': ['code', 'name_file'],
},
}]
# Sending a model request with a description of the functions
responses = []
for responses in llm.chat(messages=messages, functions=functions, stream=True):
pass
# Adding the model's response to the message history
messages.extend(responses)
last_response = messages[-1]
# If the model wants to call a function (function_call), then we call it
if last_response.get('function_call', None):
try:
available_functions = {
'save_and_run_code': save_and_run_code,
}
function_name = last_response['function_call']['name']
function_to_call = available_functions[function_name]
# Arguments for the function
function_args = json.loads(last_response['function_call']['arguments'])
# Calling the function (saving, installing dependencies, running code)
function_response = function_to_call(
code=function_args.get('code'),
name_file=function_args.get('name_file'),
dependencies=function_args.get('dependencies'),
)
# Checking the result (success or error)
if function_response.get("success"):
print("Code executed successfully!")
print(f"Result: {function_response['output']}")
break
else:
error_description = function_response.get("error")
print(f"Error detected: {error_description}")
# You can ask the user to clarify, or reformulate the request automatically
req_user = reformulate_request_agent(req_user, error_description)
except:
# If an error has occurred, try to reformulate
print('Error during function call.')
req_user = reformulate_request_agent(req_user)
else:
# The model could not generate a valid function_call
print("The model could not generate the function. Let's try to reformulate the query.")
req_user = reformulate_request_agent(req_user2, "The model did not generate a valid query.")
if __name__ == '__main__':
test()
How to launch: python agent.py
After that, a prompt will appear in the console: "Enter your code description:".For example, you can enter: Write a program that outputs numbers from 1 to 5.
The agent will try to generate the code, save it, install dependencies (if specified), and execute.
As an illustrative example, we can ask our AI agent to generate code that draws a Sierpinski triangle (often called a pyramid) in Python using the turtle module. The agent does not always cope the first time: errors, typos, or incorrect function calls may occur. However, after several clarifications, he proposed the following working code:
import turtle
def sierpinski(degree, points):
"""
A recursive function that draws a Sierpinski triangle
depending on the depth of the degree recursion and the coordinates of the points.
"""
colormap = ['blue', 'red', 'green', 'white', 'yellow', 'violet']
draw_triangle(points, colormap[degree % 6])
if degree > 0:
sierpinski(degree - 1,
{
'left': get_mid(points['left'], points['top']),
'right': get_mid(points['right'], points['top']),
'top': points['top']
})
sierpinski(degree - 1,
{
'left': points['left'],
'right': get_mid(points['left'], points['right']),
'top': get_mid(points['left'], points['right'])
})
sierpinski(degree - 1,
{
'left': get_mid(points['right'], points['left']),
'right': points['right'],
'top': get_mid(points['right'], points['top'])
})
def draw_triangle(points, color):
"""
Draws a filled triangle based on coordinates in the points dictionary.
"""
turtle.fillcolor(color)
turtle.up()
turtle.goto(points['left'])
turtle.down()
turtle.begin_fill()
turtle.goto(points['right'])
turtle.goto(points['top'])
turtle.goto(points['left'])
turtle.end_fill()
def get_mid(p1, p2):
"""
Returns the coordinate of the midpoint between two points (p1 and p2).
"""
return ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
# Setting up the turtle window
wn = turtle.Screen()
wn.bgcolor('black')
# We define three main points (vertices) of a large triangle
points = {
'left': (-300, -150),
'right': (300, -150),
'top': (0, 300)
}
# Draw a Sierpinski triangle with a depth of 5
sierpinski(5, points)
# Hiding the "turtle" and waiting for the window to close
turtle.hideturtle()
wn.exitonclick()
- The main function of sierpinski(degree, points):Draws a triangle at each recursion level.If degree > 0, it calls itself three times with new coordinates ("sub-triangles") of a smaller size.
- Draws a triangle at each recursion level.
- If degree > 0, it calls itself three times with new coordinates ("sub-triangles") of a smaller size.
- The draw_triangle(points, color) function:Gets a dictionary with three coordinates ('left', 'right', 'top') and fills the triangle with the appropriate color.
- Gets a dictionary with three coordinates ('left', 'right', 'top') and fills the triangle with the appropriate color.
- get_mid function(p1, p2):Returns the midpoint of the segment between p1 and p2.
- Returns the midpoint of the segment between p1 and p2.
- Configuring the turtle window.Screen(), selects the background color, and sets the base coordinates for the large triangle.
- sierpinski challenge(5, points) it gives the depth of recursion (the number of levels of "cutting") — the greater the depth, the more detailed the drawing, but the longer the rendering.
- At first, the agent could generate incomplete or incorrect code, where variables or functions were not declared, or important parts of the logic were skipped.
- After the agent was informed about the error (or he found the error himself at startup), he reformulated the request and adjusted his code.
- As a result, after several iterations, a working example was obtained.
This perfectly illustrates the pros and cons of using the beta version of the AI agent.:
- Plus: the agent can do most of the routine and "remember" syntax, rendering, recursion, etc.
- Minus: when an error occurs, one does not always immediately understand how to fix it; sometimes it requires the intervention of a person who will accurately point out the problem.
Thus, our AI agent, although not perfect, is already helping to save time and simplify the process of creating code — even for building such curious shapes as the Sierpinski triangle (or pyramid) using the turtle library.
- Full automation: The AI agent works locally and performs all the steps from code generation to its launch.
- Saving time and effort: You don't need to switch between the code editor, terminal, and browser to find dependencies — the agent takes care of it.
- Beta version: It is important to remember that the system is still a bit damp and does not always handle errors correctly. There may be a situation when she gets "stuck" trying to fix the code.
- A ready-made framework for expansion: Do you want to add checks, add tests, or implement support for other languages? All this is possible within the same architecture, where the model interacts with Python functions.
Enjoy using it!
Представьте: вы вводите одно-единственное описание задачи, а искусственный интеллект полностью сам пишет нужный код, сохраняет его в файл, автоматически устанавливает необходимые зависимости (если они требуются) и сразу же запускает полученный скрипт!И всё это в локальном окружении, без отправки вашего кода в чужое «облако». Если происходит ошибка, AI-агент может сам понять, что пошло не так, и скорректировать запрос к модели, пытаясь устранить проблему. Это действительно впечатляет!
Как и любая экспериментальная технология, этот AI-агент далёк от идеала и может допускать ошибки:
- Возможны ложные срабатывания или ситуации, когда агент не сможет правильно исправить ошибку и будет бесконечно переформулировать запрос.
- Код, который генерирует агент, может иногда не работать так, как вы ожидаете. Иногда могут появляться логические ошибки или несоответствия с вашим окружением.
Важно понимать, что это пока бета-версия и не гарантирует 100% стабильной работы. В некоторых случаях придётся вручную вмешиваться и корректировать результат. Однако даже сейчас это демонстрирует, насколько далеко продвинулась автоматизация разработки.
- Python 3.8+Убедитесь, что у вас установлена современная версия Python. Проверить можно командой: python --version
2. LLM-сервер Ollama (или другой вариант локального/удалённого LLM-сервера)
- В примере код настроен на сервер по адресу http://localhost:11434/v1.
- Если вы используете Ollama, запустите Ollama-сервер локально. Убедитесь, что он принимает запросы на нужном порту (по умолчанию 11434).
- Если вы хотите использовать другой LLM-сервис, замените адрес http://localhost:11434/v1 на соответствующий.
3. qwen_agent (или аналогичный пакет для взаимодействия с вашей LLM)
- Установите через PyPI: pip install qwen-agent
Сохраните этот код в файл, например, agent.py:
import json
import os
import subprocess
from qwen_agent.llm import get_chat_model
def reformulate_request_agent(user_request, error_description=None):
"""
Функция для переформулирования запроса к модели.
Принимает:
- user_request: исходный текст запроса от пользователя.
- error_description: сообщение об ошибке, если код не запустился.
Возвращает:
- Переформулированный текст запроса для повторной генерации кода.
"""
llm = get_chat_model({
'model': 'qwen2.5-coder:14b', # Название модели
'model_server': 'http://localhost:11434/v1', # Адрес вашего Ollama или другого LLM-сервера
'api_key': 'EMPTY', # При необходимости указать ключ
})
# Формируем сообщение для системы
base_message = user_request
if error_description:
base_message += f" Было получено сообщение об ошибке: {error_description}."
messages = [
{
'role': 'system',
'content': (
"You are an assistant that reformulates user requests to ensure they are suitable "
"for generating Python code. Your reformulated request should be clear and precise."
)
},
{'role': 'user', 'content': base_message}
]
# Здесь модель генерирует ответ (переформулированный запрос).
responses = []
for responses in llm.chat(messages=messages, stream=True):
pass
# Возвращаем итоговое переформулирование
return responses[0]['content']
def save_and_run_code(code, name_file, dependencies=None):
"""
Функция, которая:
1. Сохраняет переданный Python-код в файл.
2. Устанавливает зависимости (если указано).
3. Запускает созданный файл и возвращает результат (или ошибку).
:param code: Строка с Python-кодом.
:param name_file: Имя файла для сохранения кода.
:param dependencies: Строка со списком зависимостей (через пробел).
:return: Словарь формата {"success": bool, "output" или "error": str}
"""
# Приводим код к нужному формату (вдруг пришли эскейп-символы '\n' или '\t')
formatted_code = code.replace("\\n", "\n").replace("\\t", "\t")
# 1. Сохраняем код в файл
with open(name_file, "w", encoding="utf-8") as file:
file.write(formatted_code)
print(f"Код сохранён в файл: {name_file}")
# 2. Установка зависимостей (если они есть)
if dependencies:
print(f"Установка зависимостей: {dependencies}")
try:
# pip install <dependencies>
subprocess.run(["pip", "install"] + dependencies.split(), check=True, capture_output=True, text=True)
print("Зависимости успешно установлены.")
except subprocess.CalledProcessError as e:
error_message = f"Ошибка при установке зависимостей: {e.stderr}"
print(error_message)
return {"success": False, "error": error_message}
# 3. Запуск кода
try:
result = subprocess.run(["python", name_file], capture_output=True, text=True)
if result.returncode != 0:
# Если код вернулся с ошибкой (не 0)
return {"success": False, "error": result.stderr}
# Если всё ок, возвращаем результат
print(f"Результат выполнения файла {name_file}:\n{result.stdout}")
return {"success": True, "output": result.stdout}
except Exception as e:
print(f"Ошибка при запуске файла {name_file}: {e}")
return {"success": False, "error": str(e)}
def reformulate_request(error_description):
"""
Простейшая функция, которая формирует новый запрос с учётом ошибки.
"""
return f"Исправь ошибку: {error_description}"
def test():
"""
Основная функция, показывающая пример работы агента.
Шаги:
1. Получаем от пользователя запрос (описание задачи).
2. Формируем сообщения для LLM, где указываем, что мы хотим получить готовый Python-код.
3. Модель пытается сгенерировать код, вызывая функцию save_and_run_code.
4. Если возникает ошибка, у пользователя запрашивается обновлённый запрос (либо автоматически переформулируется).
5. Повторяем, пока не будет получен корректный результат.
Важно: Поскольку агент ещё в бета-версии, иногда могут возникать циклические попытки исправить ошибку.
Если видите, что он слишком долго не может разобраться, прервите выполнение и откорректируйте код вручную.
"""
# Подключаем модель (указываем сервер и имя модели)
llm = get_chat_model({
'model': 'qwen2.5-coder:14b', # Название модели
'model_server': 'http://localhost:11434/v1', # Адрес Ollama или другого LLM-сервера
'api_key': 'EMPTY',
})
# Пример запроса (вместо input можно просто задать строку)
req_user = str(input("Введите ваше описание кода: "))
req_user2 = req_user
while True:
# Печатаем запрос, чтобы видеть, что отправляем
print("Текущий запрос к модели:", req_user)
# Формируем сообщения для LLM
messages = [
{
'role': 'system',
'content': (
"You are an assistant that generates Python code based on user descriptions. "
"In addition to generating the code, you are responsible for providing the file name "
"where the code will be saved and a list of dependencies required to execute the code. "
"Ensure the output is executable and properly formatted."
)
},
{'role': 'user', 'content': req_user}
]
# Описываем функцию, которую модель может вызвать (function call)
functions = [{
'name': 'save_and_run_code',
'description': 'Generates Python code, saves it to a specified file, installs dependencies, and executes it.',
'parameters': {
'type': 'object',
'properties': {
'code': {
'type': 'string',
'description': 'Python code',
},
'name_file': {
'type': 'string',
'description': 'file name for saving the code',
},
'dependencies': {
'type': 'string',
'description': 'A space-separated list of dependencies to install before running the code',
},
},
'required': ['code', 'name_file'],
},
}]
# Отправляем запрос модели с описанием функций
responses = []
for responses in llm.chat(messages=messages, functions=functions, stream=True):
pass
# Добавляем ответ модели в историю сообщений
messages.extend(responses)
last_response = messages[-1]
# Если модель хочет вызвать функцию (function_call), то вызываем её
if last_response.get('function_call', None):
try:
available_functions = {
'save_and_run_code': save_and_run_code,
}
function_name = last_response['function_call']['name']
function_to_call = available_functions[function_name]
# Аргументы для функции
function_args = json.loads(last_response['function_call']['arguments'])
# Вызываем функцию (сохраняем, устанавливаем зависимости, запускаем код)
function_response = function_to_call(
code=function_args.get('code'),
name_file=function_args.get('name_file'),
dependencies=function_args.get('dependencies'),
)
# Проверяем результат (успех или ошибка)
if function_response.get("success"):
print("Код выполнен успешно!")
print(f"Результат: {function_response['output']}")
break
else:
error_description = function_response.get("error")
print(f"Обнаружена ошибка: {error_description}")
# Можно попросить пользователя уточнить, или переформулировать запрос автоматически
req_user = reformulate_request_agent(req_user, error_description)
except:
# Если произошла ошибка, пробуем переформулировать
print('Ошибка в процессе вызова функции.')
req_user = reformulate_request_agent(req_user)
else:
# Модель не смогла сгенерировать корректный function_call
print("Модель не смогла сгенерировать функцию. Попробуем переформулировать запрос.")
req_user = reformulate_request_agent(req_user2, "Модель не сформировала корректный запрос.")
if __name__ == '__main__':
test()
Как запустить: python agent.py
После этого в консоли появится приглашение: «Введите ваше описание кода:».Например, можно ввести: Напиши программу, которая выводит числа от 1 до 5.
Агент попытается сгенерировать код, сохранить его, установить зависимости (если указаны) и выполнить.
В качестве наглядного примера можно попросить нашего AI-агента сгенерировать код, рисующий треугольник Серпинского (часто называют его пирамидой) на Python с помощью модуля turtle. Агент не всегда справляется с первого раза: могут возникать ошибки, опечатки или неверные вызовы функций. Однако после нескольких уточнений он предложил следующий рабочий код:
import turtle
def sierpinski(degree, points):
"""
Рекурсивная функция, которая рисует треугольник Серпинского
в зависимости от глубины рекурсии degree и координат точек points.
"""
colormap = ['blue', 'red', 'green', 'white', 'yellow', 'violet']
draw_triangle(points, colormap[degree % 6])
if degree > 0:
sierpinski(degree - 1,
{
'left': get_mid(points['left'], points['top']),
'right': get_mid(points['right'], points['top']),
'top': points['top']
})
sierpinski(degree - 1,
{
'left': points['left'],
'right': get_mid(points['left'], points['right']),
'top': get_mid(points['left'], points['right'])
})
sierpinski(degree - 1,
{
'left': get_mid(points['right'], points['left']),
'right': points['right'],
'top': get_mid(points['right'], points['top'])
})
def draw_triangle(points, color):
"""
Рисует закрашенный треугольник по координатам в словаре points.
"""
turtle.fillcolor(color)
turtle.up()
turtle.goto(points['left'])
turtle.down()
turtle.begin_fill()
turtle.goto(points['right'])
turtle.goto(points['top'])
turtle.goto(points['left'])
turtle.end_fill()
def get_mid(p1, p2):
"""
Возвращает координату середины между двумя точками (p1 и p2).
"""
return ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
# Настраиваем окно turtle
wn = turtle.Screen()
wn.bgcolor('black')
# Определяем три основные точки (вершины) большого треугольника
points = {
'left': (-300, -150),
'right': (300, -150),
'top': (0, 300)
}
# Рисуем треугольник Серпинского глубины 5
sierpinski(5, points)
# Скрываем «черепашку» и ждём закрытия окна
turtle.hideturtle()
wn.exitonclick()
- Основная функция sierpinski(degree, points):Рисует треугольник на каждом уровне рекурсии.Если degree > 0, вызывает себя же три раза с новыми координатами («подтреугольниками») меньшего размера.
- Рисует треугольник на каждом уровне рекурсии.
- Если degree > 0, вызывает себя же три раза с новыми координатами («подтреугольниками») меньшего размера.
- Функция draw_triangle(points, color):Получает словарь с тремя координатами ('left', 'right', 'top') и закрашивает треугольник соответствующим цветом.
- Получает словарь с тремя координатами ('left', 'right', 'top') и закрашивает треугольник соответствующим цветом.
- Функция get_mid(p1, p2):Возвращает точку — середину отрезка между p1 и p2.
- Возвращает точку — середину отрезка между p1 и p2.
- Настройка окна turtle.Screen(), выбор цвета фона, и установка базовых координат для большого треугольника.
- Вызов sierpinski(5, points) даёт глубину рекурсии (количество уровней «вырезания») — чем больше глубина, тем детальнее рисунок, но дольше отрисовка.
- Сначала агент мог сгенерировать неполный или некорректный код, где не были объявлены переменные или функции, либо пропускались важные части логики.
- После того как агенту сообщили об ошибке (или он сам нашёл ошибку при запуске), он переформулировалзапрос и скорректировал свой код.
- В результате спустя несколько итераций был получен рабочий пример.
Это отлично иллюстрирует плюсы и минусы использования бета-версии AI-агента:
- Плюс: агент может выполнить большую часть рутины и «вспомнить» синтаксис, отрисовку, рекурсию и т.д.
- Минус: при возникновении ошибки не всегда сразу понимает, как её исправить; иногда требуется вмешательство человека, который точно укажет на проблему.
Таким образом, наш AI-агент хоть и не совершенен, но уже сейчас помогает экономить время и упрощает процесс создания кода — даже для построения таких любопытных фигур, как треугольник (или пирамида) Серпинского с помощью библиотеки turtle.
- Полная автоматизация: AI-агент работает локально и выполняет все шаги — от генерации кода до его запуска.
- Экономия времени и сил: Вам не нужно переключаться между редактором кода, терминалом и браузером для поиска зависимостей — агент берёт это на себя.
- Бета-версия: Важно помнить, что система пока сыровата и не всегда корректно обрабатывает ошибки. Может возникнуть ситуация, когда она «зациклится» в попытках исправить код.
- Готовая основа для расширения: Хотите дополнить проверки, добавить тесты или реализовать поддержку других языков? Всё это возможно в рамках той же архитектуры, где модель взаимодействует с функциями Python.
Приятного использования!
Share
