BambooAI

Converts natural language questions about datasets into executable Python code by routing queries through a specialized code-generation agent that understands pandas/numpy/matplotlib APIs. The system maintains transparency by returning visible, editable generated code alongside execution results, enabling users to inspect and modify the analysis logic without requiring programming knowledge.

Coordinates 11 specialized agents (planner, code generator, executor, debugger, etc.) in a pipeline pattern where each agent handles a specific phase of analysis: query understanding, planning, code generation, execution, error correction, and result synthesis. The BambooAI orchestrator manages message passing, context propagation, and agent sequencing based on query complexity and execution outcomes.

Provides a browser-based web interface (Flask backend + JavaScript frontend) enabling non-technical users to upload datasets, ask questions, view generated code, execute analyses, and navigate analysis workflows. The UI includes dataset preview, code editor, result visualization, and workflow history management. Backend handles file uploads, code execution, and result streaming.

Implements streaming of code execution results and LLM responses to the frontend in real-time, enabling users to see analysis progress without waiting for full completion. Uses Server-Sent Events (SSE) or WebSocket to push updates from Flask backend to browser, displaying intermediate results, code generation progress, and execution logs as they occur.

Abstracts LLM provider differences (OpenAI, Google Gemini, Anthropic, Ollama) behind a unified interface, enabling users to configure which model each agent uses via LLM_CONFIG.json. Supports model-specific features (function calling, streaming, vision) and enables cost optimization by assigning cheap models to simple tasks and expensive models to complex tasks. Handles provider-specific API differences transparently.

Enables customization of system prompts for each of the 11 agents via configuration files, allowing users to modify agent behavior, output format, and reasoning style without code changes. Prompts can be templated with variables (dataset schema, user context, previous results) and versioned for experimentation. Supports prompt engineering best practices like few-shot examples and chain-of-thought instructions.

Manages message passing between agents in the multi-agent pipeline, maintaining conversation history, context windows, and state across agent transitions. Implements context compression to fit large histories into LLM token limits, selective context inclusion to reduce noise, and message formatting for agent-specific requirements. Enables agents to reference previous agent outputs and build on prior analysis.

Stores previously generated code solutions and their execution results in a vector database (embeddings-based), enabling semantic similarity matching to retrieve relevant past solutions when new queries are submitted. When a new query arrives, the system embeds it, searches the vector database for semantically similar past queries, and can reuse or adapt cached solutions, reducing redundant LLM calls and improving response latency.

Encodes domain-specific knowledge (data model relationships, business rules, metric definitions) as OWL/RDF ontologies that are injected into agent prompts during query processing. The system uses ontology reasoning to enrich query context with relevant domain concepts, enabling agents to generate more semantically correct code that respects business logic and data relationships.

Automatically detects code execution errors (syntax, runtime, logic) and routes failed queries to a specialized debugging agent that analyzes the error, regenerates corrected code, and re-executes it in a loop until success or max retries. The system maintains error history and context to inform subsequent regeneration attempts, improving code quality without user intervention.

Supports both local Python execution (code runs in user's environment with direct data access) and remote execution (code runs on isolated server, suitable for untrusted code). The system abstracts execution mode selection, enabling users to choose based on security/performance trade-offs. Local mode provides fast iteration and data privacy; remote mode provides sandboxing and audit trails.

Integrates web search capabilities (via search agent) that enable queries combining real-time web data with local dataset analysis. When a query requires external information (market data, news, competitor info), the search agent retrieves relevant web results, synthesizes them with local data analysis, and generates code that incorporates both sources. Results are cached to avoid redundant searches.

Enables analysis across multiple datasets by loading auxiliary data sources (lookup tables, reference data, external CSVs) and making them available to the code generation agent. The system manages dataset relationships, handles joins/merges, and generates code that combines data from multiple sources. Dataset schemas are tracked and injected into agent context.

Tracks LLM token consumption across all agents and queries, providing detailed cost breakdowns by agent, model, and query type. The system logs token usage for every LLM call, enables cost-per-query reporting, and supports cost optimization strategies like model selection (cheap models for planning, expensive for code generation) and caching to reduce redundant calls.

Provides a command-line interface (via pd_agent_converse() method) that enables multi-turn conversational analysis where users ask sequential questions about a dataset, building on previous context. The CLI maintains conversation history, manages dataset state across turns, and enables iterative refinement of analyses without reloading data or restarting the session.