LingXi AI Writing Platform

Mon, 24 Aug 2026 00:00:00 +0000

AI-powered intelligent article creation platform built on Spring Boot 3 + Spring AI Alibaba, independently designed and developed full-stack.

Project Overview

An AI-powered intelligent article creation platform built on Spring Boot 3 + Spring AI Alibaba. As an independent full-stack project, it explores the practical application of LLMs in long-form content generation.

The system innovatively introduces a StateGraph workflow engine to orchestrate multi-agent collaboration, combined with SSE streaming output, solving the problems of long wait times and loose content structure in traditional AI generation. The system implements a complete automated loop from inspiration to image generation.

Core Features

Feature	Description
🧠 Multi-Agent Orchestration	StateGraph workflow engine for flexible orchestration of title, outline, and body generation agents
⚡ Streaming Output	SSE technology for millisecond first-token display, eliminating wait anxiety
🔄 Async Task System	ThreadPoolTaskExecutor + @Async decouples long-running operations
🖼️ Multi-Source Images	Strategy pattern for dynamic Pexels/SVG image service integration with auto-fallback
📐 Structured Output	Prompt template engine + StructuredOutputConverter for unified LLM output format
📊 Task Tracking	Progress management and result callback mechanisms

Technical Highlights

1. Multi-Agent Orchestration Architecture

StateGraph-based workflow engine replaces traditional linear calls
Title, outline, and body generation agents in serial/parallel combinations
New generation modes require only new node configuration

2. High-Concurrency Streaming Response

SSE (Server-Sent Events) integration with frontend
ThreadPoolTaskExecutor async task system
Millisecond first-token display, 50% throughput improvement

3. Fault-Tolerant Generation Pipeline

Prompt template engine + StructuredOutputConverter for unified output
Strategy pattern for multi-source image services
Auto-fallback on single source failure, 99%+ success rate

4. Async Task & Status Tracking

@Async decouples article/image generation as background tasks
Task status tracking with progress management
Significantly improved system throughput

Project Results

Architecture: StateGraph workflow engine + multi-agent orchestration
Performance: Millisecond first-token display, 50% throughput improvement
Reliability: Multi-source image auto-fallback, 99%+ success rate
Extensibility: New generation modes require only new node configuration

Project Status: ✅ Completed
GitHub:

FastAPI AI Streaming APIs with Server-Sent Events

Fri, 21 Aug 2026 00:00:00 +0000

Whiteboard: FastAPI — FastAPI AI Streaming APIs with Server-Sent Events.

Streaming improves time-to-first-byte and perceived responsiveness; it does not make model computation faster. Define event framing, completion signals, error events, and cleanup on disconnect.

Core mental model

The server emits data events and the client parses event boundaries. Do not concatenate arbitrary unescaped text into SSE; prefer JSON events with a stable type field.

Key mechanics

Use try/finally in the generator to release upstream resources. Include a request id in each event. Convert model failures into an error event and close with an explicit done signal.

Python example

import json
from fastapi.responses import StreamingResponse

async def events(prompt: str):
 try:
 async for token in provider.stream(prompt):
 yield f"data: {json.dumps({'type': 'token', 'text': token})}\n\n"
 yield "data: {\"type\":\"done\"}\n\n"
 except Exception:
 yield "data: {\"type\":\"error\",\"code\":\"upstream_failed\"}\n\n"

@app.post("/v1/chat/stream")
async def stream(req: ChatRequest):
 return StreamingResponse(events(req.message), media_type="text/event-stream")

Course focus

This article turns the whiteboard into explicit engineering boundaries: define inputs and outputs first, then decide how state, failures, and observability work. The examples use Python and focus on durable design principles rather than a particular provider version; verify APIs against the documentation for your installed dependencies.

Engineering practice

Keep business rules in the application layer instead of hiding them in untestable prompts or route handlers.
Add timeouts, bounded retries, and idempotency keys to external calls; retries are not a complete error strategy.
Record a request id, latency, input version, model/index version, and outcome without logging sensitive raw content.
Use a small fixed regression set first, then monitor quality and cost with sampled production traffic.

Common mistakes

Drawing only the happy path and omitting timeouts, empty results, rate limits, and rollback paths.
Letting one function parse input, call providers, build prompts, and persist data.
Replacing typed contracts with string conventions that can only be verified by manual integration.

Production checklist

Inputs, outputs, and error responses have explicit schemas
External dependencies have timeouts, bounded retries, rate limits, and fallbacks
Logs, metrics, and traces can be correlated to one request
Critical paths have unit tests, integration tests, and offline evaluation samples
Secrets, user content, and provider responses follow least-privilege and privacy rules

Practice

Implement the smallest loop shown on the whiteboard. Inject a timeout, an empty result, and a malformed payload, then check whether the system remains stable and diagnosable. Add one metric that proves your optimization improved quality or latency.

Hands-on exercise

Write a browser SSE client and test normal completion, upstream failure, refresh, and network disconnect. Track TTFT, full latency, and cancellation rate.

Conclusion

An AI feature becomes maintainable when every arrow on the whiteboard maps to an input, an output, and a failure strategy.

Streaming | 1byteone - Java Backend / AI Application Developer