QueryGuard-SanitizeAgent: A Multi-Strategy Natural Language Query Correction Agent Based on LangGraph

This article introduces the QueryGuard-SanitizeAgent project, a self-correcting agent system built on LangGraph, focusing on the extraction, verification, and automatic correction of natural language location queries. Addressing the pain points that traditional rule-based matching struggles with language diversity and pure large model solutions are prone to hallucinations, the system uses multiple strategies such as fuzzy matching, large model reasoning, and confidence-aware routing to achieve intelligent conversion from unstructured input to structured output.

In location services, geographic information systems, and intelligent navigation applications, natural language queries input by users often have issues such as spelling errors, ambiguous expressions, or non-standard formats. Traditional rule-based matching methods struggle to handle language diversity and uncertainty, while solutions purely relying on large language models may produce hallucinations or inconsistent outputs. The QueryGuard-SanitizeAgent project addresses this pain point by proposing an agent architecture that combines multiple correction strategies.

This project builds workflows based on LangGraph, uses Pydantic for data validation, and integrates OpenAI's large language model capabilities. As an extension of LangChain, LangGraph provides a state machine-driven multi-agent coordination mechanism, allowing the query processing flow to be clearly modeled as a graph structure of nodes and edges. Pydantic ensures type safety and validation logic for data models, providing reliable guarantees for structured output.

The core innovation of QueryGuard-SanitizeAgent lies in its multi-strategy correction architecture, where the system dynamically selects the optimal processing path based on query characteristics:

Fuzzy Matching Strategy: For common spelling errors and variant expressions, the system uses fuzzy string matching algorithms (such as Levenshtein distance, Jaro-Winkler similarity) for quick correction. This method has low computational overhead and is suitable for high-frequency error patterns.

Large Model Reasoning Strategy: When fuzzy matching cannot determine the best candidate, the system calls OpenAI's GPT model for semantic understanding and context reasoning. Large models can capture deep semantic associations and handle complex ambiguity resolution tasks.

Confidence-Aware Routing: The system calculates a confidence score for the output of each strategy and sets dynamic thresholds for routing decisions. High-confidence results are returned directly, while low-confidence results trigger manual review or user clarification requests.

The entire query processing flow can be divided into four stages:

1. Extraction Stage: Identify and extract location-related entities from user input, including place names, landmarks, address components, etc.

2. Verification Stage: Perform validity checks on the extracted entities to verify whether they exist in known geographic databases.

3. Correction Stage: Apply the multi-strategy correction mechanism to fix identified errors or non-standard expressions.

4. Structured Output Stage: Convert the processed query into a standardized structured format (e.g., JSON) for use by downstream services.

QueryGuard-SanitizeAgent can be widely applied in the following scenarios:

• Intelligent Customer Service Systems: Automatically correct location information in user inquiries to improve intent recognition accuracy
• Map Search Optimization: Handle spelling errors and colloquial expressions in user search queries
• Logistics Address Standardization: Convert non-standard address inputs into standardized formats to reduce delivery errors
• Data Cleaning Pipelines: Batch process historical query logs to build high-quality geographic location datasets

The project embodies several best practices in engineering implementation: Modular design allows each strategy component to be developed and tested independently; state management uses LangGraph's persistence mechanism to support breakpoint resumption for long processes; the error handling mechanism is comprehensive, with clear degradation strategies for abnormal situations. In addition, the project has a clear structure and complete documentation, making it easy for developers to understand and extend.

QueryGuard-SanitizeAgent demonstrates how to combine traditional algorithms with modern large model capabilities to build a robust natural language processing system. Its multi-strategy architecture provides a reusable design pattern for similar problems. Future exploration directions include: introducing more domain-specific correction strategies, supporting multi-language query processing, and optimizing strategy selection logic through reinforcement learning.