Credit report generation method and device based on multi-index context bus

Abstract

This invention relates to a credit report generation method and apparatus based on a multi-index context bus, applied in the field of artificial intelligence technology. The method includes: generating micro-contexts through three-dimensional filtering of "entity-spatiotemporal-semantic," physically isolating noisy data, effectively solving the "lost in the middle" effect of long text input in large models, and significantly improving the recall rate and inference accuracy of key risk information; replacing full parameter fine-tuning with "configurable expert skill bodies," achieving decoupling of business logic and model, allowing credit policy adjustments to take effect immediately with only configuration updates, avoiding catastrophic forgetting, and reducing model maintenance costs; and significantly reducing memory usage and IO overhead by utilizing pointer-based context transmission and lifecycle management, effectively supporting high-concurrency credit inference scenarios.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and more specifically to a method and apparatus for generating credit reports based on a multi-index context bus. Background Technology

[0002] Credit risk assessment is a core component of financial operations, and its accuracy and timeliness directly impact a financial institution's risk control capabilities and operational efficiency. Currently, credit risk assessment primarily employs two typical approaches:

[0003] Option 1 is an offline assessment model based on static historical data: This approach relies on fixed historical data such as credit reports and financial statements, passively retrieving information from the database when triggered by business needs (e.g., loan applications). The assessment process uses fixed rules and models, calculating based on only a limited number of variables, ultimately outputting a static credit risk report. The main drawbacks of this approach are: historical data has a significant lag, failing to reflect the borrower's real-time credit status; and the fixed assessment rules cannot adapt to changes in the market environment and the diversity of user behavior patterns. This results in poor timeliness, low accuracy, and difficulty in capturing dynamic risks, failing to meet the demands of modern finance for real-time risk control.

[0004] Option 2 is a knowledge graph-based method for extracting subgraphs of corporate credit data within the industry. To address the issue of low computational efficiency in credit analysis due to the large size of the full knowledge graph, this method employs "graph compression and dynamic extraction based on feature transfer." Graph entities are categorized as "important" and "unimportant." When excluding non-important entities, their feature vectors and association structures are "transferred" and integrated into the connected important entities. While this method reduces the number of nodes, it suffers from the following drawbacks: lossy compression leads to the loss of key details, failing to retain the original granularity of the data (such as specific transaction timestamps or device fingerprints), and smoothing out subtle associated risk features, potentially causing missed detections.

[0005] In addition, existing technologies have the following objective drawbacks in practical applications:

[0006] Model maintenance is costly and lacks interpretability: Existing technologies largely rely on deep learning models to generate credit scores. When credit policies are adjusted, the models need to be retrained or fine-tuned, which is time-consuming, computationally expensive, and carries the risk of "catastrophic forgetting." Furthermore, the "black box" nature of numerical scoring cannot accurately pinpoint specific document terms or transaction details, failing to meet the requirements of financial audits for "traceability" and accountability in decision-making.

[0007] The lack of intent-aware dynamic adaptation and severe noise interference are significant problems: Existing solutions typically input pre-defined static subgraphs or long texts into the model, failing to dynamically isolate irrelevant data based on the specific trial intent. This results in the model receiving a large amount of noise, increasing token consumption and easily triggering the "Lost-in-the-Middle" effect in large models, thus reducing inference accuracy.

[0008] Therefore, there is an urgent need for a credit intelligent scheduling solution that can achieve accuracy, efficiency, interpretability, and dynamic adaptability. Summary of the Invention

[0009] In view of this, the purpose of the present invention is to provide a credit report generation method and apparatus based on a multi-index context bus, which aims to solve the problems of high maintenance cost and lack of interpretability of credit risk assessment models in the prior art; loss of key details due to knowledge graph compression; and severe noise interference during large model inference, making it impossible to dynamically adapt to the review intention.

[0010] According to a first aspect of the present invention, a credit report generation method based on a multi-index context bus is provided, the method comprising:

[0011] The multimodal documents in the input credit application materials are subjected to layout analysis and semantic atomization segmentation, and the unstructured data is decomposed into discrete atomic nodes; a three-dimensional feature index containing semantic vectors, timestamp anchors and entity labels is generated for each atomic node, and the atomic nodes and their three-dimensional feature indexes are stored in a hybrid database;

[0012] Load and parse the predefined skill body configuration file;

[0013] Obtain basic information and risk snapshots of current credit cases, dynamically generate directed acyclic graphs for task execution through template matching and dynamic branching logic, and complete task dependency parsing and parallel scheduling planning of skill bodies through topological sorting;

[0014] Based on the skill body task currently to be executed in the directed acyclic graph, and based on the view strategy of the skill body, the set of atomic nodes strongly related to the current task is selected from the hybrid database through entity topology filtering, spatiotemporal window weighted filtering, and semantic relevance sorting filtering in sequence to form a micro-context;

[0015] The micro-context is injected into the system prompts of the base model in real time, and the base model is constrained to execute within the reasoning-action framework. During the execution, the confidence of the reasoning result is calculated in real time, and the execution path is dynamically adjusted or manual review is triggered according to the confidence threshold to obtain the reasoning result.

[0016] The inference result is encapsulated into a derived atomic node and written back to the hybrid database. A reference chain is constructed in which the derived atomic node points to its source atomic node. The original micro-context data occupied during this inference process is released, and only a lightweight context pointer is returned to the context bus.

[0017] The context pointer aggregates insights from all skill entities to detect logical conflicts between conclusions from different skill entities; if a conflict exists, a debate mechanism is triggered to reach a consensus; and a credit investigation report is generated based on the final consensus.

[0018] Preferably,

[0019] The semantic atomic segmentation of multimodal documents includes:

[0020] A semantic boundary recognition strategy is adopted to segment the multimodal document into multiple atomic nodes; wherein, in the semantic boundary recognition strategy, a complete accounting subject, legal clause and independent paragraph are all segmented into an atomic node;

[0021] Generate a globally unique identifier for each atomic node. This identifier must contain at least a data modality type code and a checksum generated based on content and time sequence information.

[0022] Calculate the semantic signature of atomic nodes for cross-modal semantic deduplication; when similar semantic nodes are detected, retain the node with the highest information content score and establish a merge edge relationship for the merged nodes to preserve the restoration path.

[0023] Preferably,

[0024] The process of generating a 3D feature index for each atomic node, including semantic vectors, timestamp anchors, and entity labels, includes:

[0025] The vectorization model is invoked to transform the text of atomic nodes into high-dimensional semantic vectors, and a semantic dimension index is constructed.

[0026] The temporal semantics in the text of atomic nodes are parsed using a large language model, normalized to absolute timestamps, and a spatiotemporal index is constructed.

[0027] Extract the main entities involved in the text of atomic nodes and label the entity roles to build an entity dimension index;

[0028] Also includes:

[0029] Record the original file ID and page coordinates of the atomic nodes to construct a source dimension index;

[0030] The atomic nodes and their multidimensional indexes are written to the vector database, time-series database, and graph database respectively in a transactional manner, and the index version is maintained. When any index update fails, a transaction rollback mechanism is used to ensure index consistency.

[0031] Preferably,

[0032] The skill body configuration file contains four major components: base model routing, view strategy, toolset, and thought chain template. When multiple model routes or tools are configured for the same skill body, priority sorting is used to avoid model or tool conflicts. Only configuration registration is completed at startup, and instantiation is performed as needed during inference.

[0033] Preferably,

[0034] The entity topology filtering includes: according to the task intent, retaining only atomic nodes related to the target entity and its neighboring entities within a preset hop count range from the graph database;

[0035] The spatiotemporal window weighted filtering includes: applying an adaptive time weighting function based on Gaussian decay to calculate the time weight of atomic nodes that have passed the entity topology filtering, so as to decay or remove outdated data that exceeds the business sensitive time window; wherein, the parameter σ of the Gaussian decay is automatically adapted and generated according to the business type, data type and skill body preset sensitivity coefficient.

[0036] The semantic relevance ranking and filtering includes: calculating the similarity score between the semantic vector and the task query vector of the atomic nodes that are filtered by spatiotemporal window weighting, and calculating a comprehensive score in combination with the time weight; selecting atomic nodes in descending order of comprehensive score until the preset token budget is reached to form the micro-context.

[0037] Preferably,

[0038] The process of calculating the confidence level of the inference result in real time during execution includes:

[0039] Obtain the model's self-score, the score of the fit between the tool call results and the historical benchmark, and the score of the number of referenced nodes and the coverage score;

[0040] The model's self-score, the score for the consistency between the tool call results and the historical benchmark, and the score for the number of referenced nodes and the coverage are weighted and summed to obtain the final confidence score.

[0041] If the final confidence score is lower than the first threshold, the same model is re-inferenced or the model is horizontally switched to a higher-performance base model for inference. If the score is lower than the second threshold or the inference times out for a preset number of consecutive times, the current task is upgraded to a high-confidence model and added to the manual review queue. The first threshold is greater than the second threshold.

[0042] Preferably,

[0043] The context pointer's data structure encapsulates a unique pointer identifier, a reference to the derived atomic node, an access range hash generated based on the caller's role and case permissions, a time-to-live, and an anti-forgery signature based on the hardware security module signature.

[0044] When downstream skill entities access the data pointed to by this pointer, they need to perform signature verification and permission verification, and retrieve the data through dereference operation within the lifetime.

[0045] Preferably,

[0046] The logical conflicts between the conclusions of the detection of different skill levels include:

[0047] When the risk level output by different skill sets for the same indicator exceeds a preset threshold, or when the output risk labels contradict each other, it is determined to be a logical conflict.

[0048] When a logical conflict is detected, a debate mode is triggered, generating debate prompts containing insights from both sides and cited evidence. These prompts are then handed over to a large model for adversarial reasoning, requiring the model to output the final arbitration result or prompting for manual review.

[0049] According to a second aspect of the present invention, a credit report generation apparatus based on a multi-index context bus is provided, the apparatus comprising:

[0050] Multimodal indexing module: used to perform layout analysis and semantic atomization segmentation on multimodal documents in the input credit application materials, decompose unstructured data into discrete atomic nodes; generate a three-dimensional feature index containing semantic vectors, timestamp anchors and entity labels for each atomic node, and store the atomic nodes and their three-dimensional feature indexes in a hybrid database;

[0051] Skill body configuration module: used to load and parse predefined skill body configuration files;

[0052] Dynamic task planning module: used to obtain basic information and risk snapshot of the current credit case, dynamically generate a directed acyclic graph of task execution through template matching and dynamic branching logic, and complete task dependency parsing and parallel scheduling planning of skill body through topological sorting;

[0053] The 3D filtering module is used to select a set of atomic nodes related to the current task from the hybrid database based on the view strategy of the skill body currently to be executed in the directed acyclic graph, and to form a micro-context by sequentially filtering through entity topology filtering, spatiotemporal window weighted filtering, and semantic relevance sorting.

[0054] The inference execution module is used to inject the micro-context into the system prompts of the base model in real time and constrain the base model to execute within the inference-action framework. During the execution process, the confidence level of the inference result is calculated in real time, and the execution path is dynamically adjusted or manual review is triggered according to the confidence level threshold to obtain the inference result.

[0055] Pointer return module: used to encapsulate the inference result into derived atomic nodes and write them back to the hybrid database, construct a reference chain of the derived atomic nodes pointing to their source atomic nodes; release the original micro-context data occupied during this inference process, and return only a lightweight context pointer to the context bus;

[0056] Report generation module: used to aggregate the reasoning results of all skill entities through the context pointer, detect logical conflicts between the conclusions of different skill entities; if a conflict exists, trigger a debate mechanism to form a consensus; generate a credit investigation report based on the final consensus.

[0057] The technical solutions provided by the embodiments of the present invention may include the following beneficial effects:

[0058] This application generates micro-contexts through three-dimensional filtering of "entity-spatiotemporal-semantic," physically isolating over 90% of noisy data, effectively solving the "lost in the middle" effect of long text input in large models, and significantly improving the recall rate and inference accuracy of key risk information; it adopts "configurable expert skill bodies" to replace full parameter fine-tuning, achieving decoupling of business logic and model, and credit policy adjustments only require updating the configuration to take effect immediately, avoiding catastrophic forgetting and reducing model maintenance costs; it utilizes pointer-based context transmission and lifecycle management to compress data flow between agents from GB level to KB level pointers, greatly reducing memory usage and IO overhead, effectively supporting high-concurrency credit inference scenarios; combined with the ReAct closed-loop control mechanism, it forces the model to call external sandbox tools to calculate financial indicators, eliminating the numerical illusions common in large models, and achieving accurate fusion analysis of unstructured text and structured data.

[0059] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit the invention. Attached Figure Description

[0060] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with the invention and, together with the description, serve to explain the principles of the invention.

[0061] Figure 1 This is a flowchart illustrating a credit report generation method based on a multi-index context bus according to an exemplary embodiment;

[0062] Figure 2This is a system schematic diagram of a credit report generation apparatus based on a multi-index context bus, according to another exemplary embodiment.

[0063] In the attached diagram: 1-Multimodal index module, 2-Skill body configuration module, 3-Dynamic task planning module, 4-3D filtering module, 5-Inference execution module, 6-Pointer return module, 7-Report generation module. Detailed Implementation

[0064] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numerals in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present invention. Rather, they are merely examples of apparatuses and methods consistent with some aspects of the invention as detailed in the appended claims.

[0065] Example 1

[0066] Figure 1 This is a flowchart illustrating a credit report generation method based on a multi-index context bus, according to an exemplary embodiment. Figure 1 As shown, the method includes:

[0067] S1, perform layout analysis and semantic atomization segmentation on the multimodal documents in the input credit application materials, decompose the unstructured data into discrete atomic nodes; generate a three-dimensional feature index containing semantic vectors, timestamp anchors and entity labels for each atomic node, and store the atomic nodes and their three-dimensional feature indexes in a hybrid database;

[0068] S2, loads and parses predefined skill body configuration files;

[0069] S3 obtains basic information and risk snapshots of current credit cases, dynamically generates a directed acyclic graph for task execution through template matching and dynamic branching logic, and completes task dependency parsing and parallel scheduling planning of skill bodies through topological sorting.

[0070] S4. Based on the skill body task to be executed in the directed acyclic graph, and based on the view strategy of the skill body, the set of atomic nodes strongly related to the current task is selected from the hybrid database through entity topology filtering, spatiotemporal window weighted filtering, and semantic relevance sorting filtering in sequence to form a micro-context.

[0071] S5, the micro-context is injected into the system prompts of the base model in real time, and the base model is constrained to execute within the reasoning-action framework; during the execution process, the confidence of the reasoning result is calculated in real time, and the execution path is dynamically adjusted or manual review is triggered according to the confidence threshold to obtain the reasoning result;

[0072] S6, encapsulate the inference result into a derived atomic node and write it back to the hybrid database, construct a reference chain from the derived atomic node to its source atomic node; release the original micro-context data occupied during this inference process, and return only a lightweight context pointer to the context bus;

[0073] S7, aggregate the insight information of all skill entities through the context pointer, and detect logical conflicts between the conclusions of different skill entities; if a conflict exists, trigger a debate mechanism to form a consensus; generate a credit investigation report based on the final consensus;

[0074] It is understood that this embodiment specifically includes the following steps:

[0075] Multimodal atomic node index of credit data:

[0076] This solution addresses the "information black box" and "context loss" problems caused by directly converting PDFs / images into long text input in traditional RAG solutions, as well as the pain point of unstructured data not being accurately addressable. This step employs "multimodal layout analysis" and "semantic atomization segmentation" techniques. First, a visual model is used to identify the physical structure of the document, decomposing unstructured documents (audit reports, bank statement scans) into text blocks, table fields, and seal fields. Then, abandoning traditional fixed character segmentation, a semantic boundary segmentation strategy is adopted to encapsulate complete accounting subjects or legal clauses into independent "atomic nodes." A three-dimensional feature index containing semantic vectors, timestamp anchors, and entity tags is generated for each node, and a semantic signature is calculated for cross-modal deduplication. This process transforms obfuscated documents into discrete information units that can be accurately retrieved, located, and referenced, laying the data foundation for subsequent accurate reasoning. Specific content includes:

[0077] [Input]: Credit application materials (PDF audit report, Excel bank statement, PNG scan, legal documents, etc.).

[0078] [Output]: A collection of atomic nodes stored in a hybrid database (vector database + graph database).

[0079] Multimodal layout analysis:

[0080] Visual models (such as minerU) are used to identify the physical structure of a document, dividing the page into text blocks, table areas, and stamp areas.

[0081] Table semantic reconstruction: For tables that span multiple pages or have complex headers, perform a "header merging algorithm" to convert them into Markdown or HTML format, ensuring the semantic integrity of row data.

[0082] Semantic Chunking:

[0083] Instead of using a fixed number of characters for segmentation, a semantic boundary segmentation strategy is adopted. For example, a complete accounting item, a legal clause, or a business description is considered a Node.

[0084] Assign a globally unique identifier to each segment, using the NODE_ identifier. <datatypecode> _ <epochseconds> _ <checksum>The format is as follows: DataTypeCode indicates the data modality (TEXT / IMG / TBL / INS), EpochSeconds indicates the record extraction time (UTC seconds, ensuring nodes are ordered by time), and Checksum is the last 8 digits of the CityHash of the content and source path.

[0085] If the AI ​​reads the original node and generates a new conclusion through analysis (such as "This customer's revenue has declined year-on-year, posing a risk"), it is not treated as a temporary text stream in the system, but rather encapsulated as a record in the database, forming a "derived node." It also uses the same format (such as NODE_INS_1703980800_7F3A9C1B) to ensure consistency between cross-layer references and the audit chain.

[0086] Distinctive design: Each Node also records a semantic_signature = SHA1(embed[:128]) during synchronization. This signature is used to retrieve duplicate signatures in the subsequent segmentation process. If a duplicate signature is detected in a local segment of the same file, the "semantic deduplication + frame interpolation" logic is triggered, retaining only the most informative version and merging the others. A MERGE edge is then established for the merged nodes. This mechanism allows the same fact to be uniformly mapped when it appears in different formats (tables / natural language), unlike the loose deduplication of traditional RAG that relies solely on vector similarity.

[0087] Embed (word vectors) [:128]: The first part of the vector (such as the first 64, 128, or 256 dimensions) contains the most core and macroscopic semantic information of the text; while the later dimensions (such as the 1000+ dimension) store more subtle, even noise-level features. Using embed [:128] is equivalent to extracting a "semantic thumbnail" of the text. If the first 128 dimensions of two texts are highly similar (even with the same hash value), it can be concluded that they are completely consistent in core semantics, ignoring the possible minor noise differences in the later dimensions.

[0088] The "highest information content" criterion is: based on info_score = 0.4 token_len_norm + 0.3 entity_density + 0.3 numeral_density is a metric, where token_len_norm is the length normalization value (0-1), entity_density is the number of entity tags / sentences, numeral_density is the percentage of numbers, MERGE edge records (node_keep, node_drop, info_score_delta) and retain source_file / page_idx for restoration.

[0089] Multidimensional feature labeling:

[0090] Semantic dimension: The Embedding model is used to convert the text into a high-dimensional vector (e.g., 1536-dimensional).

[0091] Spatiotemporal dimension: LLM intelligently parses complex time expressions in fragments (such as relative time semantics such as "end of last year", "within the reporting period", "up to the date of signing this agreement"), combines document metadata (such as the reporting date) to perform contextual reasoning, and normalizes them into absolute timestamps. Compared with traditional NER, LLM can accurately understand the complex temporal contextual dependencies in financial documents.

[0092] Entity dimension: Extract the set of subjects involved in the fragment (such as Borrower, Guarantor) and label the entity roles;

[0093] Source dimension: Records the original file ID and page coordinates for subsequent click tracing in auditing;

[0094] Interlocked Indexes: During the registration phase, nodes simultaneously write to VectorDB, TimeSeriesDB, and GraphDB, and maintain `index_version` (a version identifier used for index replication and synchronization). When any index update fails, the transaction rolls back and generates a `node_repair_ticket` (repair request), avoiding the common mismatch problem of "semantic indexes but no graph links". Interlocked process pseudocode:

[0095] BeginTransaction()

[0096] v_id = VectorDB.upsert(node_id, embedding)

[0097] t_id = TimeSeriesDB.upsert(node_id, time_anchor)

[0098] g_id = GraphDB.upsert(node_id, entity_refs)

[0099] Commit()

[0100] if any failure ->Rollback(); enqueue(node_id) to REPAIR_QUEUE

[0101] Registering and loading configurable Skillers:

[0102] [Core Problems Solved] This step addresses the issues of "catastrophic forgetting," high maintenance costs (in the millions), and long model iteration cycles (weeks) following changes in credit policies in traditional large-scale model fine-tuning. It proposes a "capability-configurable" architecture. The system does not rely on full-parameter training but instead instantiates "Skillers" by loading JSON-formatted configuration files. Each Skiller encapsulates a specific view strategy, toolset bindings (such as a financial calculator), and a standard operating procedure (SOP). Upon system startup, expert capabilities are dynamically registered by parsing the configuration file, achieving complete decoupling between business logic and model parameters. This architecture allows banks to adjust credit policies (such as adding ESG indicators) simply by updating the configuration file, achieving agile business responses with "zero fine-tuning." Specific details include:

[0103] [Input]: Skiller configuration file (JSON).

[0104] [Output]: The Skiller Registry initialized in memory (the registered skill body).

[0105] Configuration analysis: The system reads predefined skill configurations upon startup;

[0106] Capability registration: Each Skiller is resolved into a composite object of the following four components:

[0107] Base Model Router: Specifies the base model strategy (e.g., {"complex": "DeepSeek-R1", "simple": "Qwen-31B"}).

[0108] View Strategy: Defines the expert's dynamic slicing rules, i.e., view strategy (e.g., "only view the most recent year + financial data").

[0109] Tools Binding: Mount a dedicated toolbox (such as Python Sandbox, Internet Search API);

[0110] SOP Template: Load a fixed chain of thought prompt template;

[0111] Lazy loading strategy: The system only completes the Skiller configuration registration (loading the configuration file into the memory index), and the actual instantiation (including resource allocation and environment isolation) is delayed until execution and triggered on demand, avoiding unnecessary resource pre-occupancy. This design ensures efficient resource utilization in high-concurrency scenarios;

[0112] Conflict detection and rollback strategy: When multiple model routes or tools are configured for the same Skiller, they are sorted according to the priority field. If the priority item is short of quota, it will automatically be downgraded to the second priority item. If all fail, a skill body initialization error will be thrown and recorded in the database table to prevent incorrect configuration from affecting online inference.

[0113] Intent-driven task planning:

[0114] [Core Problem Solved] This step addresses the rigidity of traditional credit approval processes, which fail to dynamically adjust execution paths based on case complexity and risk characteristics, leading to wasted resources in simple cases or missed risks in complex cases. The solution introduces a "Master Agent" and a "Dynamic DAG Orchestration" mechanism. Based on the initial case summary and global risk snapshot, the Master Agent dynamically generates a Directed Acyclic Graph (DAG) as the execution plan through template matching and conditional logic. The system possesses adaptive branching capabilities; for example, when the "Construction in Progress" risk tag is detected, a "Construction Progress Verification" node is automatically inserted into the DAG. Simultaneously, task dependencies are resolved through topological sorting to ensure concurrent execution of parallelizable tasks (such as multi-channel data queries). This mechanism achieves Turing-complete scheduling of the approval process, ensuring optimal allocation of computational resources. Specific details include:

[0115] [Input]: Summary of basic case information, snapshot of overall risk.

[0116] [Output]: Directed Acyclic Graph (DAG) for task execution.

[0117] Global Status Reading: The Master Agent reads the case type (e.g., "Manufacturing Working Capital Loan") and the initial risk score;

[0118] Template matching and dynamic branching: Loading standard process templates. In banking lending, different loan products (such as "home loans" and "business operation loans") have completely different approval regulations. There are standard templates and dynamic branching condition triggering logic: if the initial risk score > risk threshold, or if the collateral type is identified as "construction in progress," then automatically insert "deep due diligence" or "project progress verification" nodes into the DAG;

[0119] Dependency analysis: Construct task dependencies, determine which Skillers can be executed in parallel (e.g., "Business data query" and "judicial litigation query" in parallel), generate the final DAG, use topological sorting for dependency sorting, and mark the start and end times of each node to ensure that the system continues to advance according to priority even with delays;

[0120] Risk threshold solution:

[0121]

[0122] In the formula, u segment as well as σ segment This represents the mean and standard deviation of risk scores derived from cases in the industry over the past 12 months. λ Configured by the business side (default 1.2). If historical data for a case is missing, it will revert to the global average.

[0123] Intent-based 3D multi-index filtering:

[0124]

Core Problems Solved

[0125] [Input]: The current Skiller's configuration file and all atomic nodes.

[0126] [Output]: Micro-Context for the current task.

[0127] Query vector generation: Convert the Skiller's task description into a query vector;

[0128] Entity topology filtering: Based on the configuration, only nodes related to the target entity (such as the guarantor) and its one-hop neighbors are retained;

[0129] Time window weighting: Calculate time weights using the Gaussian decay function. W t For financial analysis tasks, recent data has a weight close to 1, while outdated data has a weight close to 0.

[0130]

[0131] In the formula, W t ( n ) represents a node n The time weight represents the timeliness weight value of the data at the current time. T now Indicates the current timestamp; n.timestamp Represents a node n The timestamp, i.e., the time point when the data of this atomic node was generated;

[0132] The system uses a hierarchical configuration strategy to automatically determine the σ parameter (attenuation radius);

[0133] Tiered configuration strategies include:

[0134] Business type layer: Preset benchmark values ​​based on loan type (working capital loan σ=180 days, project loan σ=540 days, fixed asset loan σ=730 days).

[0135] Data type layer: Overlay data characteristic correction factor (cash flow data × 0.8, asset structure data × 1.5)

[0136] Dynamic adjustment layer: If a time sensitivity parameter (value 0.5-2.0) is specified in the Skiller configuration, the final σ = baseline value × type factor × sensitivity coefficient. This mechanism ensures that the optimal time decay curve is automatically matched for different business scenarios without manual calibration.

[0137] Semantic relevance ranking: Calculate the overall score:

[0138]

[0139] In the formula, α、β Automatically solve based on Skiller type (if the task focuses on semantics) α =0.8, β =0.2, if the task focuses on timeliness then α =0.2, β =0.8); Q Represents the query vector. n.vector Represents a node n semantic vector;

[0140] according to Score Select nodes in descending order until the token budget set by Skiller (e.g., 4k tokens) is reached, and then form a micro-context;

[0141] The innovation of this invention compared to traditional RAG is as follows: Traditional methods often only perform Top-K retrieval in the semantic space. This invention uses a series of filtering steps, namely "entity topology → time weight → semantic score", and includes explain_trace (which records the reason for the removal of nodes, such as "out of σ window") in the output of each layer, which facilitates traceability.

[0142] The σ adaptive parameter is not statically configured, but is derived in real time by the AutoSigma() function based on a three-part operator of business type, data type, and Skiller sensitivity. This allows different cases to be tuned simply by configuration, avoiding repeated manual parameter tuning.

[0143] The micro-context is returned along with coverage_vector = [entity_coverage, time_coverage, semantic_score], which is used for subsequent confidence judgment. Compared with the existing schemes that only return text blocks, the context completeness can be known at the scheduling layer, reducing invalid reasoning.

[0144] AutoSigma() process:

[0145] base = SIGMA_BASE[loan_type]

[0146] modifier = DATA_FACTOR[data_class]

[0147] sigma = base modifier time_sensitivity

[0148] return clamp(sigma, 30 days, 900 days)

[0149] coverage_vector calculation:

[0150] entity_coverage = |the set of entities retrieved| / |the set of target entities|;

[0151] time_coverage = Coverage time span / Target time window;

[0152] semantic_score = averageScore(n) (0-1 interval);

[0153] Real-time arrangement and execution of skill units:

[0154] [Core Problem Solved] This step addresses the issues of "hallucination" that large models are prone to when handling complex financial logic, as well as inaccurate numerical calculations and uncontrollable inference processes. It employs "Just-Injection" (JIT) and "ReAct closed-loop control" techniques. At the millisecond level of inference, the purified micro-context is injected into the model's System Prompt. During execution, the model is strictly confined within the ReAct (inference-action) framework: the model handles logical decomposition, and numerical calculations are forcibly performed using external Python sandbox tools, eliminating "mental calculation" errors. Simultaneously, the system incorporates a heterogeneous model routing mechanism, calculating the confidence score in real time. When the main model's output confidence score falls below a threshold (e.g., 0.75), it automatically downgrades routing to a backup high-intelligence model or triggers manual review. This "human-machine loop" design ensures the rigor and determinism of financial-grade inference. Specifically:

[0155] [Input]: Micro-context, System Prompt, Tool list.

[0156] [Output]: Reasoning process log, intermediate results from the tool, and final conclusion.

[0157] Just-in-Time (JIT) Injection: When inference occurs, the micro-context (containing the original text and source references) generated above is injected into the model's System Prompt;

[0158] ReAct closed-loop execution:

[0159] Thought: Analyze the context of the model to develop a computation or query plan.

[0160] Action: The model outputs function call instructions (such as calc_ratio(assets,liabilities)).

[0161] Observation: The system intercepts commands, executes code in a sandbox, and encapsulates the results into temporary atomic nodes to return to the model.

[0162] Convergence: The model generates natural language conclusions based on the tool results.

[0163] Heterogeneous routing: If the main model call times out or the confidence level is low, the system automatically downgrades the routing to the backup model for fallback analysis;

[0164] Confidence benchmark: The system calculates this at the end of each round of inference:

[0165] Confidence level = 0.5 C_self + 0.3 C_tool + 0.2 C_context

[0166] In the formula, C_self is the model's self-score (the confidence label in the 0-1 range is forced to be output by Prompt), C_tool is the degree of agreement between the tool results and the historical benchmark (e.g., a full score is given if the financial ratio deviation is within ±5%), and C_context measures the number of reference nodes and coverage (references from ≥3 different sources are considered high coverage).

[0167] Threshold strategy: If confidence level ≥ 0.75, accept directly; if confidence level ≤ 0.4 and < 0.75, trigger a lightweight retry (resample once with the same model) or switch laterally to a higher-performing base model; if confidence level < 0.4 or two consecutive timeouts, upgrade to a high-confidence model + manual review queue.

[0168] Route write-back: All model switching decisions, confidence scores, and reference node IDs are written to the log together for auditing and subsequent automated parameter tuning;

[0169] Value selection criteria:

[0170] C_self: The Prompt requires the model to output "confidence": {"value": 0-1, "reason":""} and verifies that it is consistent with the final conclusion; otherwise, it is recorded as 0.

[0171] C_tool: If the deviation of the tool's returned result from the historical average is less than 5%, it is recorded as 1; if the deviation is 5%-15%, it is recorded as 0.6; if the deviation is greater than 15%, it is recorded as 0.2; if no tool is called, it is considered as 0.4.

[0172] C_context: Calculated based on the coverage_vector attached to the micro-context mentioned above. Entity_coverage, time_coverage, and semantic_score are multiplied by 0.4, 0.3, and 0.3 respectively and then summed.

[0173] Multi-model weighting: When routing to a backup model, record (model_id, confidence_score, context_hash). If the two inference results are inconsistent and the difference exceeds the threshold (e.g., the credit rating levels differ by ≥1), it will be automatically submitted for manual review.

[0174] Pointer-based context lifecycle and structured write-back:

[0175]

Core Problems Solved

[0176] [Input]: Skiller's natural language inference results.

[0177] [Output]: Insights from the context bus and updated risk snapshots.

[0178] Information compression: The system mandates that Skiller outputs insights in standard JSON format, rather than retaining lengthy conversation histories; the format includes: a summary of conclusions, risk level, and a list of cited source IDs.

[0179] Structured write-back: Encapsulate the derived node into a new derived atomic node and store it in the atomic node database;

[0180] Constructing a reference chain: Create a directed edge (Insight_Node) - [:CITES]->(Source_Node) in the graph database, which enables reversible tracing from the "conclusion" to the "original evidence";

[0181] Virtual pointer passing and memory release: Retaining insight information nodes: Persisting the generated derived insight information nodes (including conclusion summaries, risk tags, and reference chains) to the atomic node database;

[0182] Destroy the original micro-context: Release the detailed raw text data (such as complete financial statements, contract terms, etc.) that expands in the Skiller instance, which occupies most of the memory during inference;

[0183] Passing lightweight pointers: Only the Insight_Node_ID (virtual pointer, about tens of bytes) is returned to the central control agent, ensuring that subsequent processes can access the conclusion content and its reference chain through pointer dereference operations without carrying the original data;

[0184] Pointer data structure: Virtual pointers are uniformly packaged into ContextPtr objects, as shown in the code:

[0185] {

[0186] "pointer_id": "PTR_20240101T101500_8D3A72",

[0187] "node_ref": "NODE_INS_1704104100_5BD1AC90",

[0188] "scope_hash": "d41d8cd98f",

[0189] "ttl_ms": 600000,

[0190] "signature": "ECDSA(sealer_priv, node_ref||scope_hash||ttl)"

[0191] }

[0192] `scope_hash` indicates the binding of the caller's role, case ID, and view permissions. It will fail directly if it is dereferenced by an unauthorized Agent. `ttl_ms` is automatically set by the central control based on the task's DAG phase (default 10 minutes). After the expiration, the pointer will be moved to the recycling queue.

[0193] Context lifecycle state machine: It adopts a four-state design `IDLE -> INHALE -> INFERENCE -> EXHALE -> IDLE`. Before each "INHALE", pointer verification is required to pass. In the "EXHALE" stage, `insight_checksum` is written to support consistency verification. If any stage fails, `ROLLBACK` is triggered to rebuild the micro-context or switch to a backup Skiller.

[0194] Garbage collection: The Context Bus scans expired pointers and orphaned micro-contexts every 60 seconds and asynchronously deletes temporary fragments in object storage through the `GC_OFFLOAD` task, avoiding OOM problems caused by "untimely memory release" in concurrent scenarios.

[0195] `scope_hash = SHA256(agent_id || case_id || role || view_version)`; The signing key is stored in the HSM module. The Context Bus only holds the key handle and does not directly expose the private key, ensuring that the pointer cannot be forged.

[0196] When `GC_OFFLOAD` fails, it logs the `GC_RETRY` event and backs off retrying exponentially. If it fails three times in a row, it marks the pointer as `LEAKED_PTR` and sends an alarm.

[0197] State machine update: The central control agent updates the global risk status based on the insight information (e.g., Risk_Score += 0.2).

[0198] Multi-dimensional comprehensive decision-making:

[0199] [Core Problems Solved] This step addresses the logical arbitration challenges arising from conflicting expert conclusions, as well as the shortcomings of traditional AI reports, such as lack of supporting original documentation and difficulty in meeting the "interpretability" and "traceability" requirements of financial auditing. The system employs a "conflict debate mechanism" and "automatic hyperlink anchoring" technology. The central control layer aggregates pointer-based conclusions from all experts, automatically detects logical conflicts (e.g., financial profit but tax loss), and triggers a "debate prompt" to introduce adversarial reasoning to reach consensus. When generating the final "Credit Investigation Report," the system utilizes the metadata of atomic nodes to automatically embed deep links pointing to the original data after each conclusion. Auditors can click on the conclusion to view a highlighted original PDF fragment or table row in a pop-up window. This mechanism achieves end-to-end reversible traceability from decision-making results to original evidence, completely resolving the trust crisis in the application of AI in the financial field. Specific details are as follows:

[0200] [Input]: A list of pointers to all insight information returned by Skiller.

[0201] [Output]: Credit investigation report, credit recommendation letter.

[0202] Atomic View Aggregation: The central control agent uses the collected pointers to "dereference" and pull the conclusion summaries of all Skillers from the context bus.

[0203] Conflict Detection and Debate: Check the consistency of different Skiller conclusions (e.g., financials show a profit but taxes show a loss). If a conflict is found, trigger "Debate Mode": Generate a new Prompt, introduce insights from both sides of the conflict, and require the model to weigh the pros and cons or prompt for manual review.

[0204] Report automatically generated: The "Credit Investigation Report" is assembled based on the final consensus.

[0205] Automatic hyperlinks: After each conclusion in the report, a hyperlink pointing to the atomic node is automatically embedded. Clicking the link will display a pop-up window showing the original PDF slice and the highlighted area.

[0206] Conflict criteria: If the same indicator (such as cash flow status) is given a level difference of ≥2 by different Skillers, or if one risk label is HIGH and the other is LOW, then a conflict is determined.

[0207] The debate prompt template requires the model to list the reference nodes, quantitative data, and arguments from both sides, and output the resolution field (values: accept_A, accept_B, escalate). If the resolution remains escalate after multiple rounds of debate, a manual review task is automatically generated.

[0208] Automatic hyperlink implementation: Based on Insight's node_ref, find the coordinates of the original PDF / table, call the rendering service to generate file_url?page=45&bbox=..., and write it into the rich text field of the report to ensure that clicking will locate the source fragment.

[0209] Example 2

[0210] Figure 2 This is a system schematic diagram of a credit report generation apparatus based on a multi-index context bus, according to another exemplary embodiment, the apparatus comprising:

[0211] Multimodal index module 1: used to perform layout analysis and semantic atomization segmentation on multimodal documents in the input credit application materials, decompose unstructured data into discrete atomic nodes; generate a three-dimensional feature index containing semantic vectors, timestamp anchors and entity labels for each atomic node, and store the atomic node and its three-dimensional feature index in a hybrid database;

[0212] Skill body configuration module 2: Used to load and parse predefined skill body configuration files;

[0213] Dynamic Task Planning Module 3: Used to obtain basic information and risk snapshots of current credit cases, dynamically generate a directed acyclic graph of task execution through template matching and dynamic branching logic, and complete task dependency parsing and parallel scheduling planning of skill bodies through topological sorting;

[0214] 3D filtering module 4: Based on the skill body task to be executed in the directed acyclic graph, and based on the view strategy of the skill body, sequentially filter the set of atomic nodes related to the current task from the hybrid database to form a micro-context.

[0215] Inference Execution Module 5: This module is used to inject the micro-context into the system prompts of the base model in real time and constrain the base model to execute within the inference-action framework. During execution, the confidence level of the inference result is calculated in real time, and the execution path is dynamically adjusted or manual review is triggered based on the confidence level threshold to obtain the inference result.

[0216] Pointer return module 6: used to encapsulate the inference result into derived atomic nodes and write them back to the hybrid database, construct a reference chain of the derived atomic nodes pointing to their source atomic nodes; release the original micro-context data occupied during this inference process, and return only a lightweight context pointer to the context bus;

[0217] Report generation module 7: used to aggregate insight information from all skill entities through the context pointer, detect logical conflicts between conclusions from different skill entities; if a conflict exists, trigger a debate mechanism to form a consensus; and generate a credit investigation report based on the final consensus.

[0218] It is understood that the same or similar parts in the above embodiments can be referred to each other, and the contents not described in detail in some embodiments can be referred to the same or similar contents in other embodiments.

[0219] It should be noted that in the description of this invention, the terms "first," "second," etc., are used for descriptive purposes only and should not be construed as indicating or implying relative importance. Furthermore, in the description of this invention, unless otherwise stated, "a plurality of" means at least two.

[0220] Any process or method description in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or more executable instructions for implementing a particular logical function or process, and the scope of the preferred embodiments of the invention includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as will be understood by those skilled in the art to which embodiments of the invention pertain.

[0221] It should be understood that various parts of the present invention can be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0222] Those skilled in the art will understand that all or part of the steps of the methods in the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, the program includes one or a combination of the steps of the method embodiments.

[0223] Furthermore, the functional units in the various embodiments of the present invention can be integrated into a processing module, or each unit can exist physically separately, or two or more units can be integrated into a module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium.

[0224] The storage media mentioned above can be read-only memory, disk, or optical disk, etc.

[0225] In the description of this specification, references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the invention. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0226] Although embodiments of the present invention have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting the present invention. Those skilled in the art can make changes, modifications, substitutions and variations to the above embodiments within the scope of the present invention.< / checksum> < / epochseconds> < / datatypecode>

Claims

1. A credit report generation method based on multi-index context bus, characterized in that, The method includes: The multimodal documents in the input credit application materials are subjected to layout analysis and semantic atomization segmentation, and the unstructured data is decomposed into discrete atomic nodes; a three-dimensional feature index containing semantic vectors, timestamp anchors and entity labels is generated for each atomic node, and the atomic nodes and their three-dimensional feature indexes are stored in a hybrid database; Load and parse the predefined skill body configuration file; Obtain basic information and risk snapshots of current credit cases, dynamically generate directed acyclic graphs for task execution through template matching and dynamic branching logic, and complete task dependency parsing and parallel scheduling planning of skill bodies through topological sorting; Based on the skill body task currently to be executed in the directed acyclic graph, and based on the view strategy of the skill body, the set of atomic nodes related to the current task are selected from the hybrid database in sequence through entity topology filtering, spatiotemporal window weighted filtering, and semantic relevance sorting filtering to form a micro-context; The micro-context is injected into the system prompts of the base model in real time, and the base model is constrained to execute within the reasoning-action framework. During the execution, the confidence of the reasoning result is calculated in real time, and the execution path is dynamically adjusted or manual review is triggered according to the confidence threshold to obtain the reasoning result. The inference result is encapsulated into a derived atomic node and written back to the hybrid database. A reference chain is constructed in which the derived atomic node points to its source atomic node. The original micro-context data occupied during this inference process is released, and only a lightweight context pointer is returned to the context bus. The reasoning results of all skill entities are aggregated through the context pointer to detect logical conflicts between the conclusions of different skill entities; if a conflict exists, a debate mechanism is triggered to form a consensus; and a credit investigation report is generated based on the final consensus.

2. The method according to claim 1, characterized in that, Semantic atomic segmentation of multimodal documents includes: A semantic boundary recognition strategy is adopted to segment the multimodal document into multiple atomic nodes; wherein, in the semantic boundary recognition strategy, a complete accounting subject, legal clause and independent paragraph are all segmented into an atomic node; Generate a globally unique identifier for each atomic node. This identifier must contain at least a data modality type code and a checksum generated based on content and time sequence information. Calculate the semantic signature of atomic nodes for cross-modal semantic deduplication; when similar semantic nodes are detected, retain the node with the highest information content score and establish a merge edge relationship for the merged nodes to preserve the restoration path.

3. The method according to claim 2, characterized in that, The process of generating a 3D feature index for each atomic node, including semantic vectors, timestamp anchors, and entity labels, includes: The vectorization model is invoked to transform the text of atomic nodes into high-dimensional semantic vectors, and a semantic dimension index is constructed. The temporal semantics in the text of atomic nodes are parsed using a large language model, normalized to absolute timestamps, and a spatiotemporal index is constructed. Extract the main entities involved in the text of atomic nodes and label the entity roles to build an entity dimension index; Also includes: Record the original file ID and page coordinates of the atomic nodes to construct a source dimension index; The atomic nodes and their multidimensional indexes are written to the vector database, time-series database, and graph database respectively in a transactional manner, and the index version is maintained. When any index update fails, a transaction rollback mechanism is used to ensure index consistency.

4. The method according to claim 3, characterized in that, The skill body configuration file contains four major components: base model routing, view strategy, toolset, and thought chain template. When multiple model routes or tools are configured for the same skill body, priority sorting is used to avoid model or tool conflicts. Only configuration registration is completed at startup, and instantiation is performed as needed during inference.

5. The method according to claim 4, characterized in that, The entity topology filtering includes: according to the task intent, retaining only atomic nodes related to the target entity and its neighboring entities within a preset hop count range from the graph database; The spatiotemporal window weighted filtering includes: applying an adaptive time weighting function based on Gaussian decay to calculate the time weight of atomic nodes that have passed the entity topology filtering, so as to decay or remove outdated data that exceeds the business sensitive time window; wherein, the parameter σ of the Gaussian decay is automatically adapted and generated according to the business type, data type and skill body preset sensitivity coefficient. The semantic relevance ranking and filtering includes: calculating the similarity score between the semantic vector and the task query vector of the atomic nodes that are filtered by spatiotemporal window weighting, and calculating a comprehensive score in combination with the time weight; selecting atomic nodes in descending order of comprehensive score until the preset token budget is reached to form the micro-context.

6. The method according to claim 5, characterized in that, The process of calculating the confidence level of the inference result in real time during execution includes: Obtain the model's self-score, the score of the fit between the tool call results and the historical benchmark, and the score of the number of referenced nodes and the coverage score; The model's self-score, the score for the consistency between the tool call results and the historical benchmark, and the score for the number of referenced nodes and the coverage are weighted and summed to obtain the final confidence score. If the final confidence score is lower than the first threshold, the same model is re-inferenced or the model is horizontally switched to a higher-performance base model for inference. If the score is lower than the second threshold or the inference times out for a preset number of consecutive times, the current task is upgraded to a high-confidence model and added to the manual review queue. The first threshold is greater than the second threshold.

7. The method according to claim 6, characterized in that, The context pointer's data structure encapsulates a unique pointer identifier, a reference to the derived atomic node, an access range hash generated based on the caller's role and case permissions, a time-to-live, and an anti-forgery signature based on the hardware security module signature. When downstream skill entities access the data pointed to by this pointer, they need to perform signature verification and permission verification, and retrieve the data through dereference operation within the lifetime.

8. The method according to claim 7, characterized in that, The logical conflicts between the conclusions of the detection of different skill levels include: When the risk level output by different skill sets for the same indicator exceeds a preset threshold, or when the output risk labels contradict each other, it is determined to be a logical conflict. When a logical conflict is detected, a debate mode is triggered, generating debate prompts containing insights from both sides and cited evidence. These prompts are then handed over to a large model for adversarial reasoning, requiring the model to output the final arbitration result or prompting for manual review.

9. A credit report generation device based on a multi-index context bus, characterized in that, The device includes: Multimodal indexing module: used to perform layout analysis and semantic atomization segmentation on multimodal documents in the input credit application materials, decompose unstructured data into discrete atomic nodes; generate a three-dimensional feature index containing semantic vectors, timestamp anchors and entity labels for each atomic node, and store the atomic nodes and their three-dimensional feature indexes in a hybrid database; Skill body configuration module: used to load and parse predefined skill body configuration files; Dynamic task planning module: used to obtain basic information and risk snapshot of the current credit case, dynamically generate a directed acyclic graph of task execution through template matching and dynamic branching logic, and complete task dependency parsing and parallel scheduling planning of skill body through topological sorting; The 3D filtering module is used to select a set of atomic nodes related to the current task from the hybrid database based on the view strategy of the skill body currently to be executed in the directed acyclic graph, and to form a micro-context by sequentially filtering through entity topology filtering, spatiotemporal window weighted filtering, and semantic relevance sorting. The inference execution module is used to inject the micro-context into the system prompts of the base model in real time and constrain the base model to execute within the inference-action framework. During the execution process, the confidence level of the inference result is calculated in real time, and the execution path is dynamically adjusted or manual review is triggered according to the confidence level threshold to obtain the inference result. Pointer return module: used to encapsulate the inference result into derived atomic nodes and write them back to the hybrid database, construct a reference chain of the derived atomic nodes pointing to their source atomic nodes; release the original micro-context data occupied during this inference process, and return only a lightweight context pointer to the context bus; Report generation module: used to aggregate the reasoning results of all skill entities through the context pointer, detect logical conflicts between the conclusions of different skill entities; if a conflict exists, trigger a debate mechanism to form a consensus; generate a credit investigation report based on the final consensus.

Images