DevGPT

Transforms unstructured natural language requirements into complete, deployable microservice code through a multi-turn refinement loop. The system uses a Project Manager agent (powered by GPT) to iteratively enhance the user's description by asking clarifying questions, identifying required APIs, and creating test scenarios before passing refined specifications to the code generation phase. The Generator component then produces microservice.py, test_microservice.py, and requirements.txt files based on the refined specification, using GPT-4 or GPT-3.5-turbo with prompt engineering templates.

Manages stateful interactions with OpenAI's GPT models through a GPTSession abstraction that handles authentication, prompt engineering, response parsing, and cost tracking across multiple API calls. The system maintains session state to enable multi-turn conversations, parses structured responses from GPT (extracting code blocks, JSON, and plain text), and tracks token usage and API costs in real-time. Response parsing includes extraction of code snippets from markdown blocks, structured data from JSON responses, and error detection for malformed outputs.

Parses GPT responses to reliably extract code blocks, JSON structures, and plain text using regex-based and AST-based parsing techniques. The system handles multiple code block formats (markdown triple-backticks with language tags, indented code blocks, inline code), extracts code from mixed-content responses (e.g., explanations followed by code), and validates extracted code for syntax errors. Extracted code is then written to files or passed to subsequent generation steps.

Collects explicit user feedback during the PM refinement phase and uses it to iteratively improve the microservice specification. Users can approve or reject the PM's clarifying questions, provide additional context, or request specification changes. The system incorporates this feedback into the next iteration of the specification, creating a feedback loop that converges toward a detailed, user-approved specification before code generation begins.

Generates unit tests alongside microservice code and implements a self-healing loop that detects test failures, analyzes error messages, and automatically regenerates code to fix issues. The system runs generated test_microservice.py files, captures assertion errors and exceptions, feeds error context back to GPT with the original code, and iteratively refines the implementation until tests pass. This creates a feedback loop where the AI developer learns from test failures and improves code quality without human intervention.

Automatically packages generated microservices into Docker containers with a Dockerfile, requirements.txt, and entrypoint configuration. The Runner component executes the containerized microservice locally using Docker, and simultaneously generates a Streamlit-based web playground that provides an interactive UI for testing the microservice endpoints without manual curl commands or code. The playground is automatically generated based on the microservice's function signatures and input/output types.

Deploys generated and tested microservices to Jina AI Cloud through an automated Deployer component that handles authentication, image building, registry pushing, and cloud configuration. The system packages the Docker container, authenticates with Jina Cloud using API credentials, pushes the image to Jina's registry, and creates a cloud deployment with appropriate resource allocation and environment variables. The deployment process is abstracted behind a single CLI command, hiding the complexity of cloud infrastructure setup.

Provides a command-line interface that orchestrates the entire microservice lifecycle through discrete commands: `generate` (create microservice from description), `run` (execute locally with Streamlit UI), `deploy` (push to Jina Cloud), and `configure` (set API keys). The CLI chains these commands together in a workflow, managing state between steps and providing progress feedback. Each command is independently callable but designed to work sequentially, allowing users to generate once and deploy multiple times, or run locally before deploying.

The Project Manager agent engages users in an interactive conversation to refine vague or incomplete microservice requirements before code generation begins. The PM uses GPT to generate clarifying questions, identify missing API dependencies, create test scenarios, and build a detailed specification document. This multi-turn loop continues until the PM determines the specification is sufficiently detailed, at which point the refined description is passed to the code generation phase. The PM can ask follow-up questions based on user responses and iteratively improve the specification.

Uses predefined prompt templates for different roles (Product Manager, Developer, DevOps) to guide GPT behavior consistently across multiple generation tasks. Each role has specific instructions, output formats, and constraints embedded in the prompt template. Templates are stored separately from code logic, allowing easy customization without modifying the core system. The system injects user context, previous conversation history, and task-specific parameters into templates before sending to GPT, enabling consistent and repeatable code generation patterns.

Analyzes refined microservice specifications to identify required external APIs (e.g., payment processors, weather services, authentication providers) and automatically includes them in the generated code and requirements.txt. The system uses GPT to parse the specification and extract API dependencies, then generates appropriate import statements, configuration placeholders, and API client initialization code. Dependencies are tracked and included in the requirements.txt file with pinned versions, ensuring reproducible builds.

Tracks OpenAI API token usage and cost across all generation steps (PM refinement, code generation, testing, error recovery) and provides real-time cost feedback to users. The system calculates costs based on model pricing (GPT-3.5-turbo vs GPT-4), token counts, and number of API calls, and can optionally enforce cost limits or warn users when costs exceed thresholds. Cost data is logged and can be analyzed to optimize prompt efficiency or choose cheaper models.