Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

[Feature] flow: Agentic LLMFlow Middleware for Dynamic Tool-Driven Reasoning

Abierto
  • ¿Algo no está bien?
#63 1 comentario 0 reacciones 1 asignado Ver en GitHub

@keli-wen ya está trabajando en esto.

Desde el 15/9/2025.

Evaluación

Este issue todavía no se ha evaluado.

Descripción

area: flows stale type: feature

✨ Feature Summary

Introduce a new LLMFlow class: an agentic runtime that leverages LLMs for dynamic, tool-driven reasoning within QuantMind. This will allow the framework to autonomously plan and execute multi-step financial analysis tasks by orchestrating tools in response to user input, inspired by modern agent design patterns.

We will primarily take smolagents repo as base to develop our LLMFlow.

🎯 Motivation

The current BaseFlow supports only statically orchestrated task flows, limiting the framework's ability to respond adaptively to user goals or leverage external capabilities. By adding LLMFlow, QuantMind can:

  • Dynamically select and use tools based on LLM-driven reasoning
  • Support autonomous, multi-step task execution (e.g., query data, analyze, compare, summarize)
  • Integrate tightly with the agentic ecosystem, including future third-party or open-source toolkits

📋 Detailed Description

LLMFlow will:

  • Operate in an agentic loop, maintaining structured message history (not just a string scratchpad)
  • Delegate action planning to the LLM, which returns either a final answer or a list of tool calls
  • Execute tool calls asynchronously and append their results to the history for further reasoning
  • Support configuration via LLMFlowConfig, specifying the reasoning LLM and the set of available tools (as BaseTool instances)

🔧 Proposed Implementation

  • Add LLMFlowConfig (in quantmind/config/flows.py) to specify the reasoning LLM and available tools
  • Implement LLMFlow (in quantmind/flows/llm_flow.py), following agent middleware patterns:
    • Asynchronous reasoning loop with structured message history
    • Tool call schema generation and execution via native LLM APIs
    • Clear error handling and extensibility for new tool types
  • Provide usage and extension documentation
API Design
# quantmind/config/flows.py
class LLMFlowConfig(BaseFlowConfig):
    reasoning_llm_identifier: str
    tools: List[BaseTool]

# quantmind/flows/llm_flow.py
class LLMFlow(BaseFlow):
    async def run(self, initial_input: str, max_iterations: int = 5) -> Any:
        ...
Configuration
llmflow:
  reasoning_llm_identifier: "gpt-4-turbo"
  tools:
    - name: "company_financials"
    - name: "data_fetcher"

🎨 User Experience

Users can define a flow that reasons and acts using LLMs and a configurable set of tools. Complex tasks like “Summarize this report and compare key metrics with last quarter” become possible with minimal code changes.

📊 Use Cases

  1. Automated Report Analysis: Fetch, analyze, and summarize financial reports using multiple tools in sequence, determined at runtime.
  2. Conversational Data Exploration: Users ask natural language queries, and the agent dynamically selects tools to pull, process, and present data.
  3. Third-Party Tool Integration: Easily plug in new tools (e.g., external APIs) for domain-specific analytics.

🔗 Related Issues

  • Relates to #47 (BaseTool design and implementation)

Implementation Considerations

Breaking Changes
  • This feature would introduce breaking changes
  • This feature is backward compatible
Dependencies
  • Requires new dependencies
  • Uses existing dependencies only

Checklist

  • I have searched existing issues to avoid duplicates
  • I have provided a clear and detailed description
  • I have explained the motivation and use cases
  • I have considered the implementation approach
  • I have thought about potential breaking changes
Lenguaje dominante
Python
Estrellas
3.1k
Forks
492
Sin PR fusionados en 30 d

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de LLMQuant/quant-mind

Todos los issues de LLMQuant/quant-mind

Issues similares

Más issues de Python

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.