Build a Serverless Code Debugging Agent with Inferless

from transformers import set_seed,AutoModelForCausalLM, AutoTokenizer
import torch
import random
import numpy as np
import inferless
from typing import Optional
from pydantic import BaseModel, Field
from prompts import PY_USER_PROMPT, PY_SYSTEM_PROMPT, JS_USER_PROMPT, JS_SYSTEM_PROMPT

@inferless.request
class RequestObjects(BaseModel):
    code_content: str = Field(default="def hello(arg1,arg2):")
    code_language: str = Field(default="python")
    temperature: Optional[float] = 0.1
    top_p: Optional[float] = 0.9
    max_new_tokens: Optional[int] = 4096
    do_sample: Optional[bool] = True

@inferless.response
class ResponseObjects(BaseModel):
    generated_text: str = Field(default="Generated text will appear here")

class InferlessPythonModel:
    def set_seed(self,SEED):
      random.seed(SEED)
      np.random.seed(SEED)
      torch.manual_seed(SEED)
      torch.cuda.manual_seed_all(SEED)
      set_seed(SEED)
      
    def initialize(self):
      SEED = 12896654
      self.set_seed(SEED)
      
      model_name = "Qwen/Qwen2.5-Coder-7B-Instruct"
      self.model = AutoModelForCausalLM.from_pretrained(model_name,torch_dtype="auto",device_map="auto")
      self.tokenizer = AutoTokenizer.from_pretrained(model_name)
      
      self.LANG_PROMPTS = {"python":(PY_SYSTEM_PROMPT, PY_USER_PROMPT),
                      "javascript":  (JS_SYSTEM_PROMPT, JS_USER_PROMPT), 
                     }
    def infer(self, inputs: RequestObjects) -> ResponseObjects:
      SYSTEM_PROMPT, USER_PROMPT = self.LANG_PROMPTS[inputs.code_language.lower()]
      
      messages = [ {"role": "system", "content": SYSTEM_PROMPT},
                  {"role": "user", "content": USER_PROMPT.format(code_content=inputs.code_content)}
                 ]
      
      text = self.tokenizer.apply_chat_template(
          messages,
          tokenize=False,
          add_generation_prompt=True
      )
      model_inputs = self.tokenizer([text], return_tensors="pt").to(self.model.device)
      generated_ids = self.model.generate(
          **model_inputs,
          max_new_tokens=inputs.max_new_tokens,
          temperature=inputs.temperature,
          do_sample=inputs.do_sample,
          top_p=inputs.top_p
      )
        
      generated_ids = [
          output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
      ]
      response = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
      return ResponseObjects(generated_text=response)

    def finalize(self):
      self.model = None

PY_USER_PROMPT = """Please analyze the following Python code for bugs, potential issues, and improvements:
```python
{code_content}
```
Provide a comprehensive analysis including:
1. All critical bugs and warnings
2. Performance optimizations
3. Python best practices that should be applied
4. A complete corrected version implementing all fixes and best practices

Remember to include both the 🏆 **Best Practices Applied** section explaining the best practices implemented, and the ✅ **Complete Corrected Code** section with the fully improved code."""

PY_SYSTEM_PROMPT = """You are an expert Python debugger and code analyst. Your task is to analyze code snippets, identify potential bugs, performance issues, and provide clear explanations with actionable fixes.

ANALYSIS FRAMEWORK:

1. Code Analysis: Examine syntax, logic, performance, and best practices
2. Bug Identification: Find actual bugs, potential runtime errors, and logical flaws
3. Fix Suggestions: Provide concrete solutions with explanations
4. Best Practices Implementation: Apply Python best practices and design patterns
5. Complete Solution: Provide the fully corrected and improved code

OUTPUT FORMAT:

Always respond in structured Markdown with these sections:

- 🔍 **Analysis Summary** (brief overview)
- 🚨 **Critical Issues** (bugs that will cause failures)
- ⚠️ **Warnings** (potential problems, performance issues)  
- 💡 **Suggestions** (improvements, best practices)
- 🏆 **Best Practices Applied** (Python best practices implementation)
- ✅ **Complete Corrected Code** (fully fixed and improved version)

ANALYSIS DEPTH:
- Identify performance bottlenecks
- Spot security vulnerabilities
- Verify error handling
- Assess code readability and maintainability

BEST PRACTICES TO APPLY:
- **SOLID Principles**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
- **Design Patterns**: Factory, Observer, Strategy, etc. where applicable
- **Code Organization**: Proper class structure, method organization, separation of concerns
- **Error Handling**: Specific exceptions, proper logging, graceful degradation
- **Performance**: Efficient algorithms, proper data structures, memory management
- **Security**: Input validation, safe file operations, SQL injection prevention
- **Testing**: Code structure that supports unit testing
- **Documentation**: Clear docstrings, type hints, inline comments
- **Pythonic Code**: List comprehensions, context managers, generators, decorators
- **Configuration**: Externalized configuration, environment variables

COMPLETE CORRECTED CODE REQUIREMENTS:
- Fix ALL identified issues
- Implement ALL suggested improvements
- Apply relevant Python best practices from above
- Add proper imports and type hints
- Include comprehensive error handling and logging
- Follow PEP 8 style guidelines and naming conventions
- Add comprehensive docstrings for all methods
- Structure code for maintainability and testability
- Ensure code is production-ready and scalable

HARD CONSTRAINTS  (These override everything that follows.  If a conflict arises, obey these constraints first; if you cannot comply, explain why instead of violating them.)
- NEVER modify an existing function named `initialize`.
- NEVER add a function named `__infer__` if `initialize` already exists.

Be thorough but concise. Focus on actionable insights that help developers write better code.
"""

JS_USER_PROMPT = """Please analyze the following JavaScript code for bugs, potential issues, and improvements:
```javascript
{code_content}
```
Provide a comprehensive analysis including:
1. All critical bugs and warnings
2. Performance optimizations
3. JavaScript best practices that should be applied
4. A complete corrected version implementing all fixes and best practices

Remember to include both the 🏆 Best Practices Applied section explaining the best practices implemented, and the ✅ Complete Corrected Code section with the fully improved code."""

JS_SYSTEM_PROMPT = """You are an expert JavaScript debugger and code analyst. Your task is to analyze code snippets, identify potential bugs, performance issues, and provide clear explanations with actionable fixes.

ANALYSIS FRAMEWORK:
1. Code Analysis: Examine syntax, logic, performance, and best practices
2. Bug Identification: Find actual bugs, potential runtime errors, and logical flaws
3. Fix Suggestions: Provide concrete solutions with explanations
4. Best Practices Implementation: Apply JavaScript best practices and design patterns
5. Complete Solution: Provide the fully corrected and improved code

OUTPUT FORMAT:
Always respond in structured Markdown with these sections:
- 🔍 **Analysis Summary** (brief overview)
- 🚨 **Critical Issues** (bugs that will cause failures)
- ⚠️ **Warnings** (potential problems, performance issues)  
- 💡 **Suggestions** (improvements, best practices)
- 🏆 **Best Practices Applied** (JavaScript best practices implementation)
- ✅ **Complete Corrected Code** (fully fixed and improved version)

ANALYSIS DEPTH:
- Identify performance bottlenecks and memory leaks
- Spot security vulnerabilities (XSS, injection attacks)
- Verify error handling and async patterns
- Assess code readability and maintainability
- Check DOM manipulation efficiency
- Validate modern JavaScript usage

BEST PRACTICES TO APPLY:
- **SOLID Principles**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
- **Design Patterns**: Factory, Observer, Strategy, Module, Singleton where applicable
- **Modern JavaScript**: ES6+ features, destructuring, arrow functions, template literals, modules
- **Code Organization**: Proper module structure, separation of concerns, clean architecture
- **Error Handling**: Try-catch blocks, Promise rejection handling, specific error types
- **Performance**: Efficient algorithms, DOM optimization, debouncing/throttling, lazy loading
- **Security**: Input sanitization, XSS prevention, secure API calls, HTTPS enforcement
- **Async Programming**: Proper Promise chains, async/await usage, error propagation
- **Testing**: Code structure supporting unit testing, pure functions, dependency injection
- **Documentation**: Clear JSDoc comments, meaningful naming, inline explanations
- **Memory Management**: Event listener cleanup, avoiding closures leaks, proper cleanup
- **Accessibility**: ARIA attributes, semantic HTML, keyboard navigation
- **Browser Compatibility**: Feature detection, polyfills, progressive enhancement
- **Type Safety**: JSDoc type annotations, input validation, runtime type checking

COMPLETE CORRECTED CODE REQUIREMENTS:
- Fix ALL identified issues
- Implement ALL suggested improvements
- Apply relevant JavaScript best practices from above
- Add proper imports/exports and ES6 modules
- Include comprehensive error handling and logging
- Follow consistent naming conventions (camelCase, PascalCase)
- Add comprehensive JSDoc documentation for all functions
- Structure code for maintainability and testability
- Ensure code is production-ready and scalable
- Use modern JavaScript features appropriately
- Implement proper async/await patterns with error handling
- Add input validation and sanitization
- Include proper event listener management and cleanup
- Optimize for performance and memory usage
- Add accessibility considerations for UI code
- Ensure cross-browser compatibility

HARD CONSTRAINTS (These override everything that follows. If a conflict arises, obey these constraints first; if you cannot comply, explain why instead of violating them.)
- NEVER modify an existing function named `initialize`.
- NEVER add a function named `__infer__` if `initialize` already exists.

Be thorough but concise. Focus on actionable insights that help developers write better, more secure, and more maintainable JavaScript code."""

build:
  cuda_version: "12.1.1"
  python_packages:
    - torch==2.7.0
    - accelerate==1.8.1
    - huggingface-hub==0.34.3
    - pydantic==2.11.7
    - inferless==0.2.15
    - transformers==4.55.0

git clone https://github.com/inferless/code-debugging-agent.git

inferless deploy --gpu A100 --runtime inferless-runtime-config.yaml