fastapi

This work addresses the redundancy and inconsistency arising from maintaining separate HTTP endpoints and Model Context Protocol (MCP) tool registrations in current large language model (LLM) tool development, which leads to duplicated business logic and boilerplate code. To resolve this, the authors propose a skill-centric unified framework that treats the skill registry as the single source of truth. Leveraging Pydantic type annotations and content negotiation, the framework dynamically generates FastAPI endpoints with Server-Sent Events (SSE) streaming support, interactive OpenAPI documentation, and zero-configuration MCP tools. This approach ensures seamless compatibility with both streaming and non-streaming clients while preserving type consistency. Evaluation across six representative skills demonstrates a 74% reduction in boilerplate code compared to manual dual-stack implementations, without sacrificing any capabilities of the FastAPI ecosystem.

This work addresses the challenges of manual Web API integration testing, which is time-consuming, error-prone, and often misaligned with business requirements. The authors propose a novel approach that synergistically combines large language models (LLMs), retrieval-augmented generation (RAG), and prompt engineering to jointly parse natural language business requirements and OpenAPI specifications, thereby automatically generating executable test scripts that are both semantically meaningful and syntactically correct. Evaluated on ten real-world APIs, the method successfully produced valid tests for 89% of the business requirements within three attempts, uncovered multiple previously unknown integration defects, and substantially reduced the manual effort required for test development.

This work addresses the time-consuming, error-prone manual development of Galaxy wrappers for command-line tools, which hinders scientific reproducibility. The authors propose an automated approach that generates compliant Galaxy XML wrappers by parsing structured metadata from Python tools’ argparse interfaces—specifically leveraging the metavar attribute to embed convention-based meta-information. This method enables fully automated, end-to-end integration into Galaxy without human intervention. Demonstrating both novelty and scalability, the approach has successfully generated a complete Galaxy tool suite for the anvi’o bioinformatics framework, encompassing hundreds of programs, thereby enabling seamless workflow execution within the Galaxy platform.

Stack Overflow hosts vast quantities of unstructured, non-executable code snippets that lack standardization, hindering direct reuse and integration into software projects. Method: This paper introduces APIzation—a novel task that automatically transforms such fragmented code into callable, testable, standardized APIs. We propose the first LLM-powered Chrome extension specifically designed for this task, integrating chain-of-thought (CoT) reasoning and few-shot learning to emulate developer expertise in method naming, parameter inference, and return-logic generation. Contribution/Results: Compared to conventional rule-based approaches, our method achieves significant improvements in functional correctness and engineering usability on real-world Stack Overflow code snippets. It enables end-to-end, browser-native, instantaneous API generation—marking the first solution of its kind. This work establishes a new, automated, low-error paradigm for community-driven code reuse, substantially lowering barriers to practical snippet integration.

This work addresses the high manual overhead and conceptual abstraction challenges faced by researchers and developers in Python package development. We propose a human-AI collaborative, end-to-end package auto-generation framework. Our method introduces a novel multi-stage large language model (LLM) orchestration paradigm, integrating structured prompt distillation, prompt augmentation, and a dual-track Human/LLM evaluation mechanism. Leveraging open-source autoregressive models—including CodeLlama and Phi-3—it jointly generates production-ready code, modular architecture, unit tests, and comprehensive documentation. Empirical evaluation demonstrates an 89% human-verified pass rate for generated packages, a 3.2× improvement in documentation completeness, and a 76% reduction in development cycle time. All source code, prompts, and usage examples are publicly released under an open license, enabling reproducible, extensible, and ethically grounded AI-augmented software engineering practice.

This work addresses the significant token redundancy in existing OpenAPI specifications when used in large language model (LLM) contexts, which hampers inference efficiency. To mitigate this, the authors propose LAPIS—a lightweight, LLM-optimized API specification that substantially reduces context length while preserving essential semantics. LAPIS achieves this through domain-specific constructs such as centralized error definitions, webhook trigger conditions, structured rate-limiting policies, and declarative operation workflows. Designed as a domain-specific language, LAPIS supports automatic conversion from OpenAPI 3.x without requiring a custom parser and remains compatible with the cl100k_base tokenizer. Experiments on five real-world APIs—including GitHub and Twilio—demonstrate that LAPIS reduces token consumption by 85.5% and 88.6% on average compared to OpenAPI YAML and JSON representations, respectively.

This work addresses persistent challenges in software library upgrades—including high manual effort, error-prone interventions, and technical debt accumulation—by proposing an automated migration approach leveraging GitHub Copilot’s Agent Mode. We systematically evaluate its effectiveness on cross-version upgrades of SQLAlchemy. A key contribution is the novel definition of “migration coverage,” a metric quantifying the proportion of required code modifications successfully applied; this enables, for the first time, an empirical assessment of Copilot Agent’s performance on multi-step library migrations. Experimental results show a median migration coverage of 100%, confirming strong syntactic code-editing capability. However, functional correctness remains limited: the median test pass rate is only 39.75%, revealing critical weaknesses in semantic consistency and contextual reasoning inherent to current LLM-based agents. The study delivers a reproducible evaluation framework for automated dependency governance and provides foundational empirical evidence to guide future research and tool development.

This work addresses the challenge that Python scripts authored by remote sensing scientists often lack scalability for large-scale satellite data processing. To bridge this gap, the authors propose an intelligent agent system that automatically translates existing Python geospatial workflows into efficient Apache Spark programs without requiring users to learn new frameworks. The system innovatively enhances the Scala-based RDPro library’s compatibility with large language models through structured API wrappers, function alias mapping, and an error-log-driven repair mechanism. Built upon LangGraph, it implements a staged pipeline for code generation and localized correction. Experiments on real-world geospatial workflows demonstrate that the approach correctly and efficiently processes massive remote sensing datasets, substantially improving scalability while preserving the original workflow semantics.

This work addresses the challenge of automatically generating high-performance computing (HPC) code that simultaneously preserves contextual awareness and structural consistency within complex codebases. To this end, the authors propose an in-terminal CLI framework that integrates large language models (LLMs), retrieval-augmented generation (RAG), and abstract syntax tree (AST) analysis. Their key innovation lies in embedding AST-derived structural information into the RAG retrieval process to construct high-fidelity prompts, thereby enabling structure-preserving, precise code generation. Experimental evaluation on representative HPC projects such as AMReX demonstrates that the proposed approach effectively produces high-quality code adhering to existing structural conventions and programming paradigms, significantly enhancing both development efficiency and code consistency.

This paper addresses the low efficiency in specification authoring, code generation, and iterative debugging during API-first development of RESTful microservices. We propose a multi-agent collaborative framework powered by large language models (LLMs), which decouples OpenAPI specification generation, server-side code synthesis, and feedback-driven refinement—guided by execution logs and error messages—into specialized, interoperable agents. This architecture establishes a closed-loop iterative optimization process, substantially enhancing LLMs’ capability to detect and rectify semantic inconsistencies and runtime defects. Evaluated on the PRAB benchmark, our approach generates functionally complete, business-logic-consistent service code in a single pass for small-to-medium-complexity APIs, reducing average iteration count by 62%. Results demonstrate significant improvements in development efficiency, functional correctness, and system robustness.