Merge pull request oracle-devrel#107 from jasperan/main

agentic_rag fixes

Author: paulparkinson

.github/workflows/agentic_rag_integration.yml

@@ -0,0 +1,154 @@
+name: agentic_rag integration tests
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'apps/agentic_rag/src/**'
+      - 'apps/agentic_rag/tests/conftest.py'
+      - 'apps/agentic_rag/tests/integration/**'
+      - 'apps/agentic_rag/requirements.txt'
+      - 'apps/agentic_rag/docker-compose.test.yml'
+      - '.github/workflows/agentic_rag_integration.yml'
+  workflow_dispatch: {}
+  schedule:
+    # Nightly at 04:17 UTC. Odd minute to avoid the top-of-hour queue.
+    - cron: '17 4 * * *'
+
+concurrency:
+  group: agentic-rag-integration-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  integration:
+    name: Full-stack integration
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    defaults:
+      run:
+        working-directory: apps/agentic_rag
+    env:
+      ORACLE_DB_USERNAME: SYSTEM
+      ORACLE_DB_PASSWORD: OraclePW1_
+      ORACLE_DB_DSN: localhost:1521/FREEPDB1
+      OLLAMA_HOST: http://127.0.0.1:11434
+      OLLAMA_TEST_MODEL: gemma3:270m
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Free disk space
+        # Oracle DB Free image is ~2GB, torch deps are ~2GB, Ollama model + binary
+        # is ~500MB. Default GitHub runner has 14GB free on /. Strip preinstalled
+        # software we don't need to avoid running out mid-test.
+        run: |
+          sudo rm -rf /usr/share/dotnet /opt/ghc /usr/local/lib/android \
+                      /usr/local/share/boost "${AGENT_TOOLSDIRECTORY}" || true
+          df -h
+        working-directory: ${{ github.workspace }}
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+          cache: 'pip'
+          cache-dependency-path: apps/agentic_rag/requirements.txt
+
+      - name: Start Oracle Database Free container
+        run: |
+          docker run -d \
+            --name oracle-free \
+            -p 1521:1521 \
+            -e ORACLE_PWD=${ORACLE_DB_PASSWORD} \
+            -e ORACLE_CHARACTERSET=AL32UTF8 \
+            container-registry.oracle.com/database/free:latest
+          echo "Oracle container started. Waiting for DB to be ready..."
+
+      - name: Install Ollama
+        run: |
+          curl -fsSL https://ollama.com/install.sh | sh
+          # Start Ollama in the background.
+          nohup ollama serve > /tmp/ollama.log 2>&1 &
+          # Wait for it to accept connections.
+          for i in {1..30}; do
+            if curl -sf http://127.0.0.1:11434/api/tags > /dev/null; then
+              echo "Ollama is up"
+              break
+            fi
+            sleep 2
+          done
+
+      - name: Pull Ollama test model
+        run: ollama pull ${OLLAMA_TEST_MODEL}
+
+      - name: Install Python dependencies
+        # Install only what the integration tests need, not the full
+        # requirements.txt (which pulls in torch, docling, etc. and can OOM
+        # the runner). oracledb + langchain-oracledb drive the DB tests;
+        # ollama is the Python SDK; playwright drives the Gradio UI test;
+        # requests + httpx cover HTTP; pytest-asyncio lets us drop back
+        # to async if needed.
+        run: |
+          python -m pip install --upgrade pip
+          pip install \
+            pytest \
+            pytest-asyncio \
+            oracledb \
+            "langchain-oracledb" \
+            "langchain-core" \
+            ollama \
+            playwright \
+            requests \
+            httpx \
+            "fastapi" \
+            "uvicorn" \
+            "python-multipart" \
+            pyyaml
+
+      - name: Install Playwright Chromium
+        run: |
+          python -m playwright install --with-deps chromium
+
+      - name: Wait for Oracle DB to be ready
+        # Oracle DB Free takes ~90-150 seconds to finish startup. Poll the
+        # container's built-in status script.
+        run: |
+          for i in {1..60}; do
+            if docker exec oracle-free /opt/oracle/checkDBStatus.sh 2>/dev/null | grep -q "READY"; then
+              echo "Oracle DB is ready"
+              docker exec oracle-free /opt/oracle/checkDBStatus.sh || true
+              break
+            fi
+            echo "Waiting for Oracle DB... (${i}/60)"
+            sleep 5
+          done
+          # Final readiness probe: can we actually connect?
+          python -c "
+          import oracledb, os
+          c = oracledb.connect(
+              user=os.environ['ORACLE_DB_USERNAME'],
+              password=os.environ['ORACLE_DB_PASSWORD'],
+              dsn=os.environ['ORACLE_DB_DSN'],
+          )
+          cur = c.cursor()
+          cur.execute('SELECT 1 FROM DUAL')
+          assert cur.fetchone() == (1,)
+          print('Oracle DB connection verified')
+          "
+
+      - name: Run integration tests
+        # -m '' overrides the default 'not integration' from pyproject.toml,
+        # then -m integration selects just the integration suite.
+        run: |
+          pytest tests/integration/ -v -m integration \
+            --tb=short \
+            -o addopts=""
+
+      - name: Dump Oracle container logs on failure
+        if: failure()
+        run: |
+          docker logs --tail 200 oracle-free || true
+          cat /tmp/ollama.log 2>/dev/null | tail -100 || true
+
+      - name: Stop Oracle container
+        if: always()
+        run: docker stop oracle-free || true

.github/workflows/agentic_rag_smoke.yml

@@ -0,0 +1,37 @@
+name: agentic_rag smoke tests
+
+on:
+  pull_request:
+    paths:
+      - 'apps/agentic_rag/src/**'
+      - 'apps/agentic_rag/tests/test_smoke_reasoning.py'
+      - '.github/workflows/agentic_rag_smoke.yml'
+  push:
+    branches: [main]
+    paths:
+      - 'apps/agentic_rag/src/**'
+      - 'apps/agentic_rag/tests/test_smoke_reasoning.py'
+      - '.github/workflows/agentic_rag_smoke.yml'
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/agentic_rag
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install minimal test deps
+        # Intentionally NOT installing requirements.txt -- the smoke test
+        # stubs out agent_reasoning and mocks OraDBVectorStore, so it needs
+        # only pytest. This keeps CI fast and hermetic.
+        run: pip install pytest
+
+      - name: Run reasoning smoke tests
+        run: pytest tests/test_smoke_reasoning.py -v

apps/agentic_rag/docker-compose.test.yml

@@ -0,0 +1,43 @@
+# Oracle Database Free container for local integration testing.
+#
+# Usage:
+#   docker compose -f docker-compose.test.yml up -d
+#   # Wait ~2 minutes for "DATABASE IS READY TO USE" in logs
+#   docker compose -f docker-compose.test.yml logs -f oracle-free
+#   # Then run:
+#   pytest -m integration
+#   # Teardown:
+#   docker compose -f docker-compose.test.yml down -v
+#
+# The matching conftest.py fixtures default to:
+#   ORACLE_DB_DSN=localhost:1521/FREEPDB1
+#   ORACLE_DB_USERNAME=SYSTEM
+#   ORACLE_DB_PASSWORD=OraclePW1_
+#
+# Note: Oracle's publicly available free container is "23ai Free". The user
+# may refer to it as "26ai free" but the image tag is database/free:latest
+# which tracks the current free release.
+
+services:
+  oracle-free:
+    image: container-registry.oracle.com/database/free:latest
+    container_name: agentic-rag-oracle-free
+    environment:
+      ORACLE_PWD: OraclePW1_
+      ORACLE_CHARACTERSET: AL32UTF8
+    ports:
+      - "1521:1521"
+    volumes:
+      - oracle-free-data:/opt/oracle/oradata
+    healthcheck:
+      # Reports healthy once the listener accepts connections. Full DB
+      # startup still takes ~2 minutes; use `docker logs` to wait for
+      # "DATABASE IS READY TO USE" before running tests.
+      test: ["CMD", "/opt/oracle/checkDBStatus.sh"]
+      interval: 10s
+      timeout: 5s
+      retries: 30
+      start_period: 120s
+
+volumes:
+  oracle-free-data:

apps/agentic_rag/gradio_app.py

@@ -288,6 +288,8 @@ def convert_to_tuples_format(history):
             else:
                 # Assistant message without preceding user message
                 tuples.append([None, content])
+        elif isinstance(item, str):
+            tuples.append([None, item])
         i += 1
     return tuples
 
@@ -1122,73 +1124,6 @@ async def collect_events():
 
 def create_interface():
     """Create Gradio interface"""
-    # Workaround for Gradio schema parsing bug with additionalProperties
-    # This error occurs when Gradio tries to generate API info from function signatures
-    # We'll patch the get_api_info method to handle errors gracefully and prevent blocking
-    original_blocks_init = gr.Blocks.__init__
-    
-    def patched_blocks_init(self, *args, **kwargs):
-        """Patched Blocks.__init__ that adds defensive API info generation"""
-        try:
-            original_blocks_init(self, *args, **kwargs)
-        except Exception as e:
-            # If Blocks initialization fails, log but continue
-            print(f"Warning: Error during Blocks initialization: {type(e).__name__}: {str(e)}")
-            # Try to continue with minimal initialization
-            try:
-                original_blocks_init(self, *args, **kwargs)
-            except:
-                pass
-        
-        # Safely get the original get_api_info method
-        try:
-            original_get_api_info = self.get_api_info
-        except AttributeError:
-            # If get_api_info doesn't exist, create a dummy method
-            original_get_api_info = lambda: {}
-        
-        def safe_get_api_info():
-            """Safely get API info, never raising exceptions to prevent blocking"""
-            try:
-                api_info = original_get_api_info()
-                # Ensure we always return a dict, even if None
-                return api_info if isinstance(api_info, dict) else {}
-            except TypeError as e:
-                if "argument of type 'bool' is not iterable" in str(e) or "additionalProperties" in str(e):
-                    # Return empty API info to avoid crashing
-                    return {}
-                # Catch all TypeError and return empty dict
-                print(f"Warning: TypeError generating API info: {str(e)}")
-                return {}
-            except ValueError as e:
-                # Handle value errors during API generation
-                print(f"Warning: ValueError generating API info: {str(e)}")
-                return {}
-            except AttributeError as e:
-                # Handle attribute errors during API generation
-                print(f"Warning: AttributeError generating API info: {str(e)}")
-                return {}
-            except KeyError as e:
-                # Handle key errors during API generation
-                print(f"Warning: KeyError generating API info: {str(e)}")
-                return {}
-            except (ImportError, ModuleNotFoundError) as e:
-                # Handle import errors during API generation
-                print(f"Warning: Import error generating API info: {str(e)}")
-                return {}
-            except Exception as e:
-                # Catch all other errors and log but don't crash
-                print(f"Warning: Unexpected error generating API info: {type(e).__name__}: {str(e)}")
-                return {}
-        
-        # Safely assign the patched method
-        try:
-            self.get_api_info = safe_get_api_info
-        except Exception as e:
-            print(f"Warning: Could not patch get_api_info: {str(e)}")
-    
-    # Temporarily patch Blocks class
-    gr.Blocks.__init__ = patched_blocks_init
 
     # Helper function to render Agent Cards
     def render_agent_cards():
@@ -1232,9 +1167,8 @@ def render_agent_cards():
                         with gr.Column():
                             gr.Markdown("#### Synthesizer B (Concise)")
                             gr.JSON(value=all_cards.get("synthesizer_agent_v2", {}))
-    
-    try:
-        with gr.Blocks(title="Agentic RAG System") as interface:
+
+    with gr.Blocks(title="Agentic RAG System", css=CUSTOM_CSS, theme=gr.themes.Soft()) as interface:
             gr.Markdown("""
             # 🤖 Agentic RAG System
             
@@ -2075,16 +2009,13 @@ def run_all_a2a_tests():
                 outputs=[a2a_chatbot],
                 api_name=False
             )
-            a2a_clear_button.click(lambda: None, None, a2a_chatbot, queue=False, api_name=False)
+            a2a_clear_button.click(lambda: [], None, a2a_chatbot, queue=False, api_name=False)
             # a2a_status_button removed from Chat tab
 
             # Checkbox event listener removed
 
 
             return interface
-    finally:
-        # Restore original Blocks.__init__
-        gr.Blocks.__init__ = original_blocks_init
 
 def main():
     # Check configuration
@@ -2111,9 +2042,7 @@ def main():
         server_name="0.0.0.0",
         server_port=7860,
         share=True,
-        inbrowser=True,
-        css=CUSTOM_CSS,
-        theme=gr.themes.Soft()
+        inbrowser=True
     )
 
 def download_model(model_type: str) -> str:

apps/agentic_rag/run_app.py

@@ -68,8 +68,7 @@ def start_gradio_ui(host: str = "0.0.0.0", port: int = 7860):
 
     try:
         # Import here to avoid loading Gradio unnecessarily
-        from gradio_app import create_interface, CUSTOM_CSS
-        import gradio as gr
+        from gradio_app import create_interface
 
         print(f"\n🎨 Starting Gradio UI on http://{host}:{port}")
 
@@ -79,8 +78,6 @@ def start_gradio_ui(host: str = "0.0.0.0", port: int = 7860):
             server_port=port,
             share=False,  # Don't create public link in unified mode
             inbrowser=False,  # Don't auto-open browser
-            css=CUSTOM_CSS,
-            theme=gr.themes.Soft(),
             quiet=True
         )
     except Exception as e:

apps/agentic_rag/src/a2a_handler.py

@@ -331,7 +331,11 @@ async def handle_agent_query(self, params):
                 # Query vector store for actual findings
                 try:
                     search_query = step if step else query
-                    vs_results = self.vector_store.query(search_query, n_results=3) if self.vector_store else []
+                    # OraDBVectorStore has no generic .query(); default to the PDF collection
+                    vs_results = (
+                        self.vector_store.query_pdf_collection(search_query, n_results=3)
+                        if self.vector_store else []
+                    )
                     findings = []
                     for doc in vs_results:
                         findings.append({