Update app.py

app.py

@@ -3,22 +3,21 @@ from typing import Optional
 
 import gradio as gr
 import pandas as pd
-from smolagents import CodeAgent, LiteLLMModel, tool
 
+from minimal_agent import MinimalAgent
 
-# Tool definitions to showcase smolagents capabilities
-@tool
 def analyze_dataframe(df: pd.DataFrame, analysis_type: str) -> str:
-    """Analyze a pandas DataFrame"""
+    """Basic DataFrame analysis"""
     if analysis_type == "summary":
         return str(df.describe())
     elif analysis_type == "info":
-        return str(df.info())
+        buffer = []
+        df.info(buf=buffer)
+        return "\n".join(buffer)
     return "Unknown analysis type"
 
-@tool
 def plot_data(df: pd.DataFrame, plot_type: str) -> None:
-    """Create plots from DataFrame"""
+    """Basic plotting function"""
     import matplotlib.pyplot as plt
     import seaborn as sns
     
@@ -31,21 +30,18 @@ def plot_data(df: pd.DataFrame, plot_type: str) -> None:
         plt.tight_layout()
 
 def process_file(file: gr.File) -> Optional[pd.DataFrame]:
-    """Process uploaded file into a DataFrame"""
+    """Process uploaded file into DataFrame"""
     if not file:
         return None
-        
+    
     try:
         if file.name.endswith('.csv'):
-            df = pd.read_csv(file.name)
+            return pd.read_csv(file.name)
         elif file.name.endswith(('.xlsx', '.xls')):
-            df = pd.read_excel(file.name)
-        else:
-            return None
-        return df
+            return pd.read_excel(file.name)
     except Exception as e:
-        print(f"Error reading {file.name}: {str(e)}")
-        return None
+        print(f"Error reading file: {str(e)}")
+    return None
 
 def analyze_data(
     file: gr.File,
@@ -53,68 +49,56 @@ def analyze_data(
     api_key: str,
     temperature: float = 0.7,
 ) -> str:
-    """Process user request and generate analysis using smolagents"""
+    """Process user request and generate analysis"""
     
     if not api_key:
         return "Error: Please provide an API key."
-        
+    
     if not file:
         return "Error: Please upload a file."
-        
+    
     try:
         # Set up environment
         os.environ["OPENAI_API_KEY"] = api_key
         
-        # Create model and agent
-        model = LiteLLMModel(
+        # Create agent
+        agent = MinimalAgent(
             model_id="gpt-4o-mini",
             temperature=temperature
         )
         
-        # Create agent with various tools
-        agent = CodeAgent(
-            tools=[analyze_dataframe, plot_data],
-            model=model,
-            additional_authorized_imports=[
-                "pandas",
-                "numpy",
-                "matplotlib",
-                "seaborn",
-                "plotly",
-                "sklearn",
-                "scipy"
-            ],
-            max_steps=5,
-            verbosity_level=1
+        # Add tools
+        agent.add_tool(
+            "analyze_dataframe",
+            "Analyze DataFrame with various metrics",
+            analyze_dataframe
+        )
+        agent.add_tool(
+            "plot_data",
+            "Create various plots from DataFrame",
+            plot_data
         )
         
-        # Process uploaded file
+        # Process file
         df = process_file(file)
         if df is None:
-            return "Error: Could not process uploaded file."
-        
+            return "Error: Could not process file."
+            
         # Build context
         file_info = f"""
-        Uploaded file: {file.name}
-        DataFrame Shape: {df.shape}
+        File: {file.name}
+        Shape: {df.shape}
         Columns: {', '.join(df.columns)}
+        
         Column Types:
         {chr(10).join([f'- {col}: {dtype}' for col, dtype in df.dtypes.items()])}
         """
         
-        # Build prompt
+        # Run analysis
         prompt = f"""
         {file_info}
-
-        The data has been loaded into a pandas DataFrame called 'df'.
-        Available tools:
-        - analyze_dataframe: Perform basic DataFrame analysis
-        - plot_data: Create various plots
         
-        Additional capabilities:
-        - Full pandas, numpy, matplotlib, seaborn access
-        - Machine learning with sklearn
-        - Statistical analysis with scipy
+        The data is loaded in a pandas DataFrame called 'df'.
         
         User request: {query}
         
@@ -125,9 +109,7 @@ def analyze_data(
         4. Key insights and findings
         """
         
-        # Run analysis
-        result = agent.run(prompt, additional_args={"df": df})
-        return result
+        return agent.run(prompt)
         
     except Exception as e:
         return f"Error occurred: {str(e)}"
@@ -135,30 +117,29 @@ def analyze_data(
 def create_interface():
     """Create Gradio interface"""
     
-    with gr.Blocks(title="AI Agent Testing Interface") as interface:
+    with gr.Blocks(title="AI Data Analysis Assistant") as interface:
         gr.Markdown("""
-        # AI Agent Testing Interface
+        # AI Data Analysis Assistant
         
-        Test the capabilities of AI agents using smolagents library. Upload data files and ask questions in natural language.
+        Upload your data file and ask questions in natural language.
         
         **Features:**
         - Data analysis and visualization
-        - Machine learning capabilities
         - Statistical analysis
-        - Custom tool integration
+        - Machine learning capabilities
         
-        **Note**: Requires your own API key for GPT-4.
+        **Note**: Requires your own GPT-4 API key.
         """)
         
         with gr.Row():
             with gr.Column():
                 file = gr.File(
-                    label="Upload Data File (CSV/Excel)",
+                    label="Upload Data File",
                     file_types=[".csv", ".xlsx", ".xls"]
                 )
                 query = gr.Textbox(
                     label="What would you like to analyze?",
-                    placeholder="e.g., Analyze the relationships between variables and create visualizations",
+                    placeholder="e.g., Create visualizations showing relationships between variables",
                     lines=3
                 )
                 api_key = gr.Textbox(
@@ -178,25 +159,22 @@ def create_interface():
             with gr.Column():
                 output = gr.Markdown(label="Output")
         
-        # Handle submissions
         analyze_btn.click(
             analyze_data,
             inputs=[file, query, api_key, temperature],
             outputs=output
         )
         
-        # Example queries
         gr.Examples(
             examples=[
-                [None, "Perform comprehensive exploratory data analysis including distributions, correlations, and key statistics"],
-                [None, "Create visualizations showing relationships between numeric variables"],
-                [None, "Identify and analyze outliers in the dataset"],
-                [None, "Perform clustering analysis and visualize the results"],
-                [None, "Calculate summary statistics and create box plots for numeric columns"],
+                [None, "Show key statistics and create visualizations for numeric columns"],
+                [None, "Find correlations and patterns in the data"],
+                [None, "Identify outliers and unusual patterns"],
+                [None, "Create summary visualizations of the main variables"],
             ],
             inputs=[file, query]
         )
-        
+    
     return interface
 
 if __name__ == "__main__":