Streamline code migration utilizing Amazon Nova Premier with an agentic workflow

Many enterprises are burdened with mission-critical techniques constructed on outdated applied sciences which have turn out to be more and more tough to take care of and prolong.

This submit demonstrates how you should utilize the Amazon Bedrock Converse API with Amazon Nova Premier inside an agentic workflow to systematically migrate legacy C code to fashionable Java/Spring framework purposes. By breaking down the migration course of into specialised agent roles and implementing strong suggestions loops, organizations can accomplish the next:

• Cut back migration time and price – Automation handles repetitive conversion duties whereas human engineers concentrate on high-value work.
• Enhance code high quality – Specialised validation brokers be certain that the migrated code follows fashionable finest practices.
• Decrease threat – The systematic method prevents important enterprise logic loss throughout migration.
• Allow cloud integration – The ensuing Java/Spring code can seamlessly combine with AWS providers.

Challenges

Code migration from legacy techniques to fashionable frameworks presents a number of vital challenges that require a balanced method combining AI capabilities with human experience:

• Language paradigm variations – Changing C code to Java includes navigating basic variations in reminiscence administration, error dealing with, and programming paradigms. C’s procedural nature and direct reminiscence manipulation distinction sharply with Java’s object-oriented method and computerized reminiscence administration. Though AI can deal with many syntactic transformations robotically, builders should evaluate and validate the semantic correctness of those conversions.
• Architectural complexity – Legacy techniques typically characteristic advanced interdependencies between elements that require human evaluation and planning. In our case, the C code base contained intricate relationships between modules, with some TPs (Transaction Applications) linked to as many as 12 different modules. Human builders should create dependency mappings and decide migration order, usually ranging from leaf nodes with minimal dependencies. AI can help in figuring out these relationships, however the strategic choices about migration sequencing require human judgment.
• Sustaining enterprise logic – Ensuring important enterprise logic is precisely preserved throughout translation requires steady human oversight. Our evaluation confirmed that though computerized migration is very profitable for easy, well-structured code, advanced enterprise logic embedded in bigger information (over 700 strains) requires cautious human evaluate and sometimes handbook refinement to forestall errors or omissions.
• Inconsistent naming and constructions – Legacy code typically accommodates inconsistent naming conventions and constructions that have to be standardized throughout migration. AI can deal with many routine transformations—changing alphanumeric IDs in perform names, reworking C-style error codes to Java exceptions, and changing C structs into Java lessons—however human builders should set up naming requirements and evaluate edge instances the place automated conversion could also be ambiguous.
• Integration complexity – After changing particular person information, human-guided integration is important for making a cohesive utility. Variable names that had been constant throughout the unique C information typically turn out to be inconsistent throughout particular person file conversion, requiring builders to carry out reconciliation work and facilitate correct inter-module communication.
• High quality assurance – Validating that transformed code maintains purposeful equivalence with the unique requires a mixture of automated testing and human verification. That is notably important for advanced enterprise logic, the place refined variations can result in vital points. Builders should design complete check suites and carry out thorough code opinions to make sure migration accuracy.

These challenges necessitate a scientific method that mixes the sample recognition capabilities of enormous language fashions (LLMs) with structured workflows and important human oversight to supply profitable migration outcomes. The secret’s utilizing AI to deal with routine transformations whereas preserving people within the loop for strategic choices, advanced logic validation, and high quality assurance.

Resolution overview

The answer employs the Amazon Bedrock Converse API with Amazon Nova Premier to transform legacy C code to fashionable Java/Spring framework code by means of a scientific agentic workflow. This method breaks down the advanced migration course of into manageable steps, permitting for iterative refinement and dealing with of token limitations. The answer structure consists of a number of key elements:

• Code evaluation agent – Analyzes C code construction and dependencies
• Conversion agent – Transforms C code to Java/Spring code
• Safety evaluation agent – Identifies vulnerabilities in legacy and migrated code
• Validation agent – Verifies conversion completeness and accuracy
• Refine agent – Rewrites the code based mostly on the suggestions from the validation agent
• Integration agent – Combines individually transformed information

Our agentic workflow is applied utilizing a Strands Brokers framework mixed with the Amazon Bedrock Converse API for strong agent orchestration and LLM inference. The structure (as proven within the following diagram) makes use of a hybrid method that mixes Strands’s session administration capabilities with customized BedrockInference dealing with for token continuation.

The answer makes use of the next core applied sciences:

• Strands Brokers framework (v1.1.0+) – Supplies agent lifecycle administration, session dealing with, and structured agent communication
• Amazon Bedrock Converse API – Powers the LLM inference with Amazon Nova Premier mannequin
• Customized BedrockInference class – Handles token limitations by means of textual content prefilling and response continuation
• Asyncio-based orchestration – Permits concurrent processing and non-blocking agent execution

The workflow consists of the next steps:

1. Code evaluation:

• Code evaluation agent – Performs enter code evaluation to know the conversion necessities. Examines C code base construction, identifies dependencies, and assesses complexity.
• Framework integration – Makes use of Strands for session administration whereas utilizing BedrockInference for evaluation.
• Output – JSON-structured evaluation with dependency mapping and conversion suggestions.

2. File categorization and metadata creation:

• Implementation – FileMetadata information class with complexity evaluation.
• Classes – Easy (0–300 strains), Medium (300–700 strains), Advanced (over 700 strains).
• File varieties – Normal C information, header information, and database I/O (DBIO) information.

3. Particular person file conversion:

• Conversion agent – Performs code migration on particular person information based mostly on the data from the code evaluation agent.
• Token dealing with – Makes use of the stitch_output() methodology for dealing with massive information that exceed token limits.

4. Safety evaluation part:

• Safety evaluation agent – Performs complete vulnerability evaluation on each legacy C code and transformed Java code.
• Danger categorization – Classifies safety points by severity (Essential, Excessive, Medium, Low).
• Mitigation suggestions – Supplies particular code fixes and safety finest practices.
• Output – Detailed safety report with actionable remediation steps.

5. Validation and suggestions loop:

• Validation agent – Analyzes conversion completeness and accuracy.
• Refine agent – Applies iterative enhancements based mostly on validation outcomes.
• Iteration management – Most 5 suggestions iterations with early termination on passable outcomes.
• Session persistence – Strands framework maintains dialog context throughout iterations.

6. Integration and finalization:

• Integration agent – Makes an attempt to mix individually transformed information.
• Consistency decision – Standardizes variable naming and offers correct dependencies.
• Output technology – Creates cohesive Java/Spring utility construction.

7. DBIO conversion (specialised)

• Objective – Converts SQL DBIO C supply code to MyBatis XML mapper information.
• Framework – Makes use of the identical Strands and BedrockInference hybrid method for consistency.

The answer consists of the next key orchestration options:

• Session persistence – Every conversion maintains session state throughout agent interactions.
• Error restoration – Complete error dealing with with swish degradation.
• Efficiency monitoring – Constructed-in metrics for processing time, iteration counts, and success charges.
• Token continuation – Seamless dealing with of enormous information by means of response stitching.

This framework-specific implementation facilitates dependable, scalable code conversion whereas sustaining the pliability to deal with various C code base constructions and complexities.

Stipulations

Earlier than implementing this code conversion resolution, ensure you have the next elements configured:

• AWS surroundings:
  • AWS account with acceptable permissions for Amazon Bedrock with Amazon Nova Premier mannequin entry
  • Amazon Elastic Compute Cloud (Amazon EC2) occasion (t3.medium or bigger) for improvement and testing or improvement surroundings in native machine
• Growth setup:
  • Python 3.10+ put in with Boto3 SDK and Strands Brokers
  • AWS Command Line Interface (AWS CLI) configured with acceptable credentials and AWS Area
  • Git for model management of legacy code base and transformed code
  • Textual content editor or built-in improvement surroundings (IDE) able to dealing with each C and Java code bases
• Supply and goal code base necessities:
  • C supply code organized in a structured listing format
  • Java 11+ and Maven/Gradle construct instruments
  • Spring Framework 5.x or Spring Boot 2.x+ dependencies

The supply code and prompts used within the submit may be discovered within the GitHub repo.

Agent-based conversion course of

The answer makes use of a classy multi-agent system applied utilizing the Strands framework, the place every agent makes a speciality of a particular side of the code conversion course of. This distributed method offers thorough evaluation, correct conversion, and complete validation whereas sustaining the pliability to deal with various code constructions and complexities.

Strands framework integration

Every agent extends the BaseStrandsConversionAgent class, which offers a hybrid structure combining Strands session administration with customized BedrockInference capabilities:

class BaseStrandsConversionAgent(ABC):
    def (self, identify: str, bedrock_inference, system_prompt: str):
        self.identify = identify
        self.bedrock = bedrock_inference  # Customized BedrockInference for token dealing with
        self.system_prompt = system_prompt
        
        # Create strands agent for session administration
        self.strands_agent = Agent(identify=identify, system_prompt=system_prompt)
    
    async def execute_async(self, context: ConversionContext) -> Dict[str, Any]:
        # Applied by every specialised agent
        cross

Code evaluation agent

The code evaluation agent examines the construction of the C code base, figuring out dependencies between information and figuring out the optimum conversion technique. This agent helps prioritize which information to transform first and identifies potential challenges. The next is the immediate template for the code evaluation agent:

You're a Code Evaluation Agent with experience in legacy C codebases and fashionable Java/Spring structure.


{c_code}


## TASK
Your job is to investigate the offered C code to arrange for migration.

Carry out a complete evaluation and supply the next:
## INSTRUCTIONS

1. DEPENDENCY ANALYSIS:
   - Establish all file dependencies (which information embody or reference others)
   - Map perform calls between information
   - Detect shared information constructions and international variables

2. COMPLEXITY ASSESSMENT:
   - Categorize every file as Easy (0-300 strains), Medium (300-700 strains), or Advanced (700+ strains)
   - Establish information with advanced management circulate, pointer manipulation, or reminiscence administration
   - Flag any platform-specific or hardware-dependent code

3. CONVERSION PLANNING:
   - Suggest a conversion sequence (which information to transform first)
   - Counsel logical splitting factors for big information
   - Establish frequent patterns that may be standardized throughout conversion

4. RISK ASSESSMENT:
   - Spotlight potential conversion challenges (e.g., pointer arithmetic, bitwise operations)
   - Establish business-critical sections requiring particular consideration
   - Observe any undocumented assumptions or behaviors

5. ARCHITECTURE RECOMMENDATIONS:
   - Counsel acceptable Java/Spring elements for every C module
   - Suggest DTO construction and repair group
   - Suggest database entry technique utilizing a persistence framework

Format your response as a structured JSON doc with these sections.

Conversion agent

The conversion agent handles the precise transformation of C code to Java/Spring code. This agent is assigned the function of a senior software program developer with experience in each C and Java/Spring frameworks. The immediate template for the conversion agent is as follows:

You're a Senior Software program Developer with 15+ years of expertise in each C and Java Spring framework. 


{c_code}


## TASK
Your job is to transform legacy C code to fashionable Java Spring code with precision and completeness.

## CONVERSION GUIDELINES:

1. CODE STRUCTURE:
   - Create acceptable Java lessons (Service, DTO, Mapper interfaces)
   - Protect authentic perform and variable names except they battle with Java conventions
   - Use Spring annotations appropriately (@Service, @Repository, and so on.)
   - Implement correct package deal construction based mostly on performance

2. JAVA BEST PRACTICES:
   - Use Lombok annotations (@Knowledge, @Slf4j, @RequiredArgsConstructor) to scale back boilerplate
   - Implement correct exception dealing with as an alternative of error codes
   - Exchange pointer operations with acceptable Java constructs
   - Convert C-style arrays to Java collections the place acceptable

3. SPRING FRAMEWORK INTEGRATION:
   - Use dependency injection as an alternative of worldwide variables
   - Implement a persistence framework mappers for database operations
   - Exchange direct SQL calls with mapper interfaces
   - Use Spring's transaction administration

4. SPECIFIC TRANSFORMATIONS:
   - Exchange PFM_TRY/PFM_CATCH with Java try-catch blocks
   - Convert mpfmdbio calls to a persistence framework mapper methodology calls
   - Exchange mpfm_dlcall with acceptable Service bean injections
   - Convert NGMHEADER references to enter.getHeaderVo() calls
   - Exchange PRINT_ and PFM_DBG macros with SLF4J logging
   - Convert ngmf_ strategies to CommonAPI.ngmf methodology calls

5. DATA HANDLING:
   - Create separate DTO lessons for enter and output constructions
   - Use correct Java information varieties (String as an alternative of char arrays, and so on.)
   - Implement correct null dealing with and validation
   - Take away handbook reminiscence administration code

## OUTPUT FORMAT:
   - Embrace filename on the prime of every Java file: #filename: [filename].java
   - Place executable Java code inside  tags
   - Manage a number of output information clearly with correct headers

Generate full, production-ready Java code that absolutely implements all performance from the unique C code.

Safety evaluation agent

The safety evaluation agent performs complete vulnerability evaluation on the unique C code and the transformed Java code, figuring out potential safety dangers and offering particular mitigation methods. This agent is essential for ensuring safety vulnerabilities should not carried ahead throughout migration and new code follows safety finest practices. The next is the immediate template for the safety evaluation agent:

You're a Safety Evaluation Agent with experience in figuring out vulnerabilities in each C and Java codebases, specializing in safe code migration practices.

ORIGINAL C CODE:

{c_code}


CONVERTED JAVA CODE:

{java_code}


## TASK
Your job is to carry out complete safety evaluation on each the legacy C code and transformed Java code, figuring out vulnerabilities and offering particular mitigation suggestions.

## SECURITY ANALYSIS FRAMEWORK

1. **LEGACY C CODE VULNERABILITIES:**
   - Buffer overflow dangers (strcpy, strcat, sprintf utilization)
   - Reminiscence administration points (dangling pointers, reminiscence leaks)
   - Integer overflow/underflow vulnerabilities
   - Format string vulnerabilities
   - Race circumstances in multi-threaded code
   - Improper enter validation and sanitization
   - SQL injection dangers in database operations
   - Insecure cryptographic implementations

2. **JAVA CODE SECURITY ASSESSMENT:**
   - Enter validation and sanitization gaps
   - SQL injection vulnerabilities in persistence framework queries
   - Improper exception dealing with that leaks delicate info
   - Authentication and authorization bypass dangers
   - Insecure deserialization vulnerabilities
   - Cross-site scripting (XSS) prevention in net endpoints
   - Logging of delicate information
   - Dependency vulnerabilities in Spring framework utilization

3. **MIGRATION-SPECIFIC RISKS:**
   - Safety assumptions that do not translate between languages
   - Privilege escalation by means of improper Spring Safety configuration
   - Knowledge publicity by means of overly permissive REST endpoints
   - Session administration vulnerabilities
   - Configuration safety (hardcoded credentials, insecure defaults)

4. **COMPLIANCE AND BEST PRACTICES:**
   - OWASP High 10 compliance evaluation
   - Spring Safety finest practices implementation
   - Safe coding requirements adherence
   - Knowledge safety and privateness issues

## OUTPUT FORMAT
Present your evaluation as a structured JSON with these fields:
- "critical_vulnerabilities": array of important safety points requiring rapid consideration
- "security_risk_issues": array of safety issues
- "secure_code_recommendations": particular code adjustments to implement safety fixes
- "spring_security_configurations": beneficial Spring Safety configurations
- "compliance_gaps": areas the place code would not meet safety requirements
- "migration_security_notes": safety issues particular to the C-to-Java migration

For every vulnerability, embody:
- Description of the safety threat
- Potential affect and assault vectors
- Particular line numbers or code sections affected
- Detailed remediation steps with code examples
- Precedence stage and beneficial timeline for fixes

Be thorough in figuring out each apparent and refined safety points that might be exploited in manufacturing environments.

Validation agent

The validation agent opinions the transformed code to establish lacking or incorrectly transformed elements. This agent offers detailed suggestions that’s utilized in subsequent conversion iterations. The immediate template for the validation agent is as follows:

You're a Code Validation Agent specializing in verifying C to Java/Spring migrations.

ORIGINAL C CODE:

{c_code}


CONVERTED JAVA CODE:

{java_code}


## TASK
Your job is to totally analyze the conversion high quality and establish any points or omissions.
Carry out a complete validation specializing in these facets:

## INSTRUCTIONS
1. COMPLETENESS CHECK:
   - Confirm all capabilities from C code are applied in Java
   - Affirm all variables and information constructions are correctly transformed
   - Test that each one logical branches and circumstances are preserved
   - Guarantee all error dealing with paths are applied

2. CORRECTNESS ASSESSMENT:
   - Establish any logical errors within the conversion
   - Confirm correct transformation of C-specific constructs (pointers, structs, and so on.)
   - Test for proper implementation of reminiscence administration patterns
   - Validate correct dealing with of string operations and byte manipulation

3. SPRING FRAMEWORK COMPLIANCE:
   - Confirm acceptable use of Spring annotations and patterns
   - Test correct implementation of dependency injection
   - Validate right use of persistence framework mappers
   - Guarantee correct service construction and group

4. CODE QUALITY EVALUATION:
   - Assess Java code high quality and adherence to finest practices
   - Test for correct exception dealing with
   - Confirm acceptable logging implementation
   - Consider general code group and readability

## OUTPUT FORMAT
Present your evaluation as a structured JSON with these fields:
- "full": boolean indicating if conversion is full
- "missing_elements": array of particular capabilities, variables, or logic blocks which are lacking
- "incorrect_transformations": array of components that had been incorrectly remodeled
- "spring_framework_issues": array of Spring-specific implementation points
- "quality_concerns": array of code high quality points
- "suggestions": particular, actionable suggestions for enchancment

Be thorough and exact in your evaluation, as your suggestions will instantly inform the following iteration of the conversion course of.

Suggestions loop implementation with refine agent

The suggestions loop is a important part that allows iterative refinement of the transformed code. This course of includes the next steps:

1. Preliminary conversion by the conversion agent.
2. Safety evaluation by the safety evaluation agent.
3. Validation by the validation agent.
4. Suggestions incorporation by the refine agent (incorporating each validation and safety suggestions).
5. Repeat till passable outcomes are achieved.

The refine agent incorporates safety vulnerability fixes alongside purposeful enhancements, and safety evaluation outcomes are offered to improvement groups for ultimate evaluate and approval earlier than manufacturing deployment. The next code is the immediate template for code refinement:

You're a Senior Software program Developer specializing in C to Java/Spring migration with experience in safe coding practices.
ORIGINAL C CODE:

{c_code}


YOUR PREVIOUS JAVA CONVERSION:

{previous_java_code}


VALIDATION FEEDBACK:

{validation_feedback}


SECURITY ASSESSMENT:

{security_feedback}


## TASK
You've got beforehand transformed C code to Java, however validation and safety evaluation have recognized points that have to be addressed. Your job is to enhance the conversion by addressing all recognized purposeful and safety points whereas sustaining full performance.
## INSTRUCTIONS
1. ADDRESSING MISSING ELEMENTS:
   - Implement any capabilities, variables, or logic blocks recognized as lacking
   - Guarantee all management circulate paths from the unique code are preserved
   - Add any lacking error dealing with or edge instances
2. CORRECTING TRANSFORMATIONS:
   - Repair any incorrectly remodeled code constructs
   - Appropriate any logical errors within the conversion
   - Correctly implement C-specific patterns in Java
3. IMPLEMENTING SECURITY FIXES:
   - Tackle all important and high-risk safety vulnerabilities recognized
   - Implement safe coding practices (enter validation, parameterized queries, and so on.)
   - Exchange insecure patterns with safe Java/Spring alternate options
   - Add correct exception dealing with that doesn't leak delicate info
4. IMPROVING SPRING IMPLEMENTATION:
   - Appropriate any points with Spring annotations or patterns
   - Guarantee correct dependency injection and repair construction
   - Repair persistence framework mapper implementations if wanted
   - Implement Spring Safety configurations as beneficial
5. MAINTAINING CONSISTENCY:
   - Guarantee naming conventions are constant all through the code
   - Preserve constant patterns for related operations
   - Protect the construction of the unique code the place acceptable
## OUTPUT FORMAT
Output the improved Java code inside  tags, with acceptable file headers. Guarantee all safety vulnerabilities are addressed whereas sustaining full performance from the unique C code.

Integration agent

The combination agent combines individually transformed Java information right into a cohesive utility, resolving inconsistencies in variable naming and offering correct dependencies. The immediate template for the combination agent is as follows:

You're an Integration Agent specializing in combining individually transformed Java information right into a cohesive Spring utility. 

CONVERTED JAVA FILES:

{converted_java_files}


ORIGINAL FILE RELATIONSHIPS:

{file_relationships}


## TASK
Your job is to combine a number of Java information that had been transformed from C, making certain they work collectively correctly.

Carry out the next integration duties:
## INSTRUCTIONS
1. DEPENDENCY RESOLUTION:
   - Establish and resolve dependencies between providers and elements
   - Guarantee correct autowiring and dependency injection
   - Confirm that service methodology signatures match their utilization throughout information

2. NAMING CONSISTENCY:
   - Standardize variable and methodology names that must be constant throughout information
   - Resolve any naming conflicts or inconsistencies
   - Guarantee DTO area names match throughout associated lessons

3. PACKAGE ORGANIZATION:
   - Manage lessons into acceptable package deal construction
   - Group associated performance collectively
   - Guarantee correct import statements throughout all information

4. SERVICE COMPOSITION:
   - Implement correct service composition patterns
   - Guarantee providers work together appropriately with one another
   - Confirm that information flows appropriately between elements

5. COMMON COMPONENTS:
   - Extract and standardize frequent utility capabilities
   - Guarantee constant error dealing with throughout providers
   - Standardize logging patterns

6. CONFIGURATION:
   - Create mandatory Spring configuration lessons
   - Arrange acceptable bean definitions
   - Configure any required properties or settings

Output the built-in Java code as a set of correctly organized information, every with:
- Acceptable package deal declarations
- Appropriate import statements
- Correct Spring annotations
- Clear file headers (#filename: [filename].java)

Place every file's code inside  tags. Make sure the built-in utility maintains all performance from the person elements whereas offering a cohesive construction.

DBIO conversion agent

This specialised agent handles the conversion of SQL DBIO C supply code to XML information suitable with persistence framework within the Java Spring framework. The next is the immediate template for the DBIO conversion agent:

You're a Database Integration Specialist with experience in changing C-based SQL DBIO code to persistence framework XML mappings for Spring purposes. 

SQL DBIO C SOURCE CODE:

{sql_dbio_code}


## TASK
Your job is to rework the offered SQL DBIO C code into correctly structured persistence framework XML information.

Carry out the conversion following these tips:

## INSTRUCTIONS
1. XML STRUCTURE:
   - Create a correctly formatted persistence framework mapper XML file
   - Embrace acceptable namespace matching the Java mapper interface
   - Set right resultType or resultMap attributes for queries
   - Use correct persistence framework XML construction and syntax

2. SQL TRANSFORMATION:
   - Protect the precise SQL logic from the unique code
   - Convert any C-specific SQL parameter dealing with to persistence framework parameter markers
   - Preserve all WHERE clauses, JOIN circumstances, and different SQL logic
   - Protect any feedback explaining SQL performance

3. PARAMETER HANDLING:
   - Convert C variable bindings to persistence framework parameter references (#{param})
   - Deal with advanced parameters utilizing acceptable persistence framework methods
   - Guarantee parameter varieties match Java equivalents (String as an alternative of char[], and so on.)

4. RESULT MAPPING:
   - Create acceptable resultMap components for advanced outcome constructions
   - Map column names to Java DTO property names
   - Deal with any sort conversions wanted between database and Java varieties

5. DYNAMIC SQL:
   - Convert any conditional SQL technology to persistence framework dynamic SQL components
   - Use , , , and different dynamic components as acceptable
   - Preserve the identical conditional logic as the unique code

6. ORGANIZATION:
   - Group associated queries collectively
   - Embrace clear feedback explaining the aim of every question
   - Comply with persistence framework finest practices for mapper group

## OUTPUT FORMAT
Output the transformed persistence framework XML inside  tags. Embrace a filename remark on the prime: #filename: [EntityName]Mapper.xml

Make sure the XML is well-formed, correctly indented, and follows persistence framework conventions for Spring purposes.

Dealing with token limitations

To handle token limitations within the Amazon Bedrock Converse API, we applied a textual content prefilling method that enables the mannequin to proceed producing code the place it left off. This method is especially essential for big information that exceed the mannequin’s context window and represents a key technical innovation in our Strands-based implementation.

Technical implementation

The next code implements the BedrockInference class with continuation assist:

class BedrockInference:
    def __init__(self, region_name: str = "us-east-1", model_id: str = "us.amazon.nova-premier-v1:0"):
        self.config = Config(read_timeout=300)
        self.consumer = boto3.consumer("bedrock-runtime", config=self.config, region_name=region_name)
        self.model_id = model_id
        self.continue_prompt = {
            "function": "consumer",
            "content material": [{"text": "Continue the code conversion from where you left off."}]
        }
    
    def run_converse_inference_with_continuation(self, immediate: str, system_prompt: str) -> Record[str]:
        """Run inference with continuation dealing with for big outputs"""
        ans_list = []
        messages = [{"role": "user", "content": [{"text": prompt}]}]
        
        response, cease = self.generate_conversation([{'text': system_prompt}], messages)
        ans = response['output']['message']['content'][0]['text']
        ans_list.append(ans)
        
        whereas cease == "max_tokens":
            logger.data("Response truncated, persevering with technology...")
            messages.append(response['output']['message'])
            messages.append(self.continue_prompt)
            
            # Extract previous couple of strains for continuation context
            sec_last_line="n".be part of(ans.rsplit('n', 3)[1:-1]).strip()
            messages.append({"function": "assistant", "content material": [{"text": sec_last_line}]})
            
            response, cease = self.generate_conversation([{'text': system_prompt}], messages)
            ans = response['output']['message']['content'][0]['text']
            del messages[-1]  # Take away the prefill message
            ans_list.append(ans)
        
        return ans_list

Continuation technique particulars

The continuation technique consists of the next steps:

1. Response monitoring:
   1. The system displays the stopReason area in Amazon Bedrock responses.
   2. When stopReason equals max_tokens, continuation is triggered robotically. This makes positive no code technology is misplaced because of token limitations.
2. Context preservation:
   1. The system extracts the previous few strains of generated code as continuation context.
   2. It makes use of textual content prefilling to take care of code construction and formatting. It preserves variable names, perform signatures, and code patterns throughout continuations.
3. Response stitching:

def stitch_output(self, immediate: str, system_prompt: str, tag: str = "java") -> str:
    """Sew collectively a number of responses and extract content material inside specified tags"""
    ans_list = self.run_converse_inference_with_continuation(immediate, system_prompt)
    
    if len(ans_list) == 1:
        final_ans = ans_list[0]
    else:
        final_ans = ans_list[0]
        for i in vary(1, len(ans_list)):
            # Seamlessly mix responses by eradicating overlap
            final_ans = final_ans.rsplit('n', 1)[0] + ans_list[i]
    
    # Extract content material inside specified tags (java, xml, and so on.)
    if f'<{tag}>' in final_ans and f'{tag}>' in final_ans:
        final_ans = final_ans.break up(f'<{tag}>')[-1].break up(f'{tag}>')[0].strip()
    
    return final_ans

Optimizing conversion high quality

By means of our experiments, we recognized a number of elements that considerably affect conversion high quality:

• File measurement administration – Recordsdata with greater than 300 strains of code profit from being damaged into smaller logical items earlier than conversion.
• Centered conversion – Changing completely different file varieties (C, header, DBIO) individually yields higher outcomes as every file sort has distinct conversion patterns. Throughout conversion, C capabilities are remodeled into Java strategies inside lessons, and C structs turn out to be Java lessons. Nonetheless, as a result of information are transformed individually with out cross-file context, attaining optimum object-oriented design would possibly require human intervention to consolidate associated performance, set up correct class hierarchies, and facilitate acceptable encapsulation throughout the transformed code base.
• Iterative refinement – A number of suggestions loops (4–5 iterations) produce extra complete conversions.
• Position task – Assigning the mannequin a particular function (senior software program developer) improves output high quality.
• Detailed directions – Offering particular transformation guidelines for frequent patterns improves consistency.

Assumptions

This migration technique makes the next key assumptions:

• Code high quality – Legacy C code follows cheap coding practices with discernible construction. Obfuscated or poorly structured code would possibly require preprocessing earlier than automated conversion.
• Scope limitations – This method targets enterprise logic conversion quite than low-level system code. C code with {hardware} interactions or platform-specific options would possibly require handbook intervention.
• Check protection – Complete check instances exist for the legacy utility to validate purposeful equivalence after migration. With out satisfactory checks, extra validation steps are mandatory.
• Area data – Though the agentic workflow reduces the necessity for experience in each C and Java, entry to material consultants who perceive the enterprise area is required to validate preservation of important enterprise logic.
• Phased migration – The method assumes an incremental migration technique is suitable, the place elements may be transformed and validated individually quite than a full venture stage migration.

Outcomes and efficiency

To judge the effectiveness of our migration method powered by Amazon Nova Premier, we measured efficiency throughout enterprise-grade code bases representing typical buyer situations. Our evaluation centered on two success elements: structural completeness (preservation of all enterprise logic and capabilities) and framework compliance (adherence to Spring Boot finest practices and conventions).

Migration accuracy by code base complexity

The agentic workflow demonstrated various effectiveness based mostly on file complexity, with all outcomes validated by material consultants. The next desk summarizes the outcomes.

*After a number of suggestions cycles

Key insights for enterprise adoption

These outcomes reveal an essential sample: the agentic method excels at dealing with the majority of migration work (small to medium information) whereas nonetheless offering vital worth for advanced information that require human oversight. This creates a hybrid method the place AI handles routine conversions and safety assessments, and builders concentrate on integration and architectural choices.

Conclusion

Our resolution demonstrates that the Amazon Bedrock Converse API with Amazon Nova Premier, when applied inside an agentic workflow, can successfully convert legacy C code to fashionable Java/Spring framework code. The method handles advanced code constructions, manages token limitations, and produces high-quality conversions with minimal human intervention. The answer breaks down the conversion course of into specialised agent roles, implements strong suggestions loops, and handles token limitations by means of continuation methods. This method accelerates the migration course of, improves code high quality, and reduces the potential for errors. Check out the answer on your personal use case, and share your suggestions and questions within the feedback.

Concerning the authors

Aditya Prakash is a Senior Knowledge Scientist on the Amazon Generative AI Innovation Middle. He helps clients leverage AWS AI/ML providers to unravel enterprise challenges by means of generative AI options. Specializing in code transformation, RAG techniques, and multimodal purposes, Aditya allows organizations to implement sensible AI options throughout various industries.

Jihye Search engine optimization is a Senior Deep Studying Architect who makes a speciality of designing and implementing generative AI options. Her experience spans mannequin optimization, distributed coaching, RAG techniques, AI agent improvement, and real-time information pipeline building throughout manufacturing, healthcare, gaming, and e-commerce sectors. As an AI/ML guide, Jihye has delivered production-ready options for shoppers, together with good manufacturing unit management techniques, predictive upkeep platforms, demand forecasting fashions, suggestion engines, and MLOps frameworks

Yash Shah is a Science Supervisor within the AWS Generative AI Innovation Middle. He and his group of utilized scientists, architects and engineers work on a spread of machine studying use instances from healthcare, sports activities, automotive and manufacturing, serving to clients notice artwork of the potential with GenAI. Yash is a graduate of Purdue College, specializing in human elements and statistics. Outdoors of labor, Yash enjoys images, mountain climbing and cooking.