Add DeepSeek AI integration for reaction completion: API key input, automatic reaction completion using DeepSeek-V3.2-Exp, enhanced UI with AI options, and OpenAI dependency

app.py

@@ -6,8 +6,9 @@ import re
 from functools import partial
 from io import StringIO
 from textwrap import dedent
-from typing import List, Sequence, Tuple
+from typing import List, Sequence, Tuple, Optional, Dict, Any
 from urllib.parse import quote_plus
+import json
 
 import gradio as gr
 import pandas as pd
@@ -788,19 +789,147 @@ def _render_smiles_to_svg(smiles_text: str) -> str | None:
     return svg
 
 
-def render_reaction_svg(reaction_text: str):
+def _complete_reaction_with_deepseek(partial_reaction: str, api_key: str) -> Optional[str]:
+    """Use DeepSeek API to complete missing parts of a chemical reaction."""
+    if not api_key or not partial_reaction.strip():
+        return None
+
+    try:
+        from openai import OpenAI
+
+        client = OpenAI(
+            api_key=api_key,
+            base_url="https://api.deepseek.com",
+        )
+
+        system_prompt = """
+You are a chemistry expert. The user will provide a partial chemical reaction (missing reactants or products).
+Please complete the reaction by inferring the missing components based on chemical knowledge and reaction patterns.
+
+Analyze the given reaction and determine what might be missing. Consider:
+- Conservation of mass and atoms
+- Common reaction types (combustion, substitution, addition, etc.)
+- Chemical plausibility
+- Radical reactions, ionic reactions, etc.
+
+Output in JSON format with the completed reaction.
+
+EXAMPLE INPUT:
+CH4 + O2 → CO2
+
+EXAMPLE OUTPUT:
+{"completed_reaction": "CH4 + 2O2 → CO2 + 2H2O", "reasoning": "This is a combustion reaction requiring balanced oxygen and water as product"}
+
+EXAMPLE INPUT:
+C2H5• + H2 →
+
+EXAMPLE OUTPUT:
+{"completed_reaction": "C2H5• + H2 → C2H6 + H•", "reasoning": "Hydrogen abstraction reaction where ethyl radical abstracts H from H2"}
+"""
+
+        user_prompt = f"Complete this partial chemical reaction: {partial_reaction}"
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+
+        response = client.chat.completions.create(
+            model="deepseek-chat",
+            messages=messages,
+            response_format={'type': 'json_object'},
+            max_tokens=500,
+            temperature=0.1
+        )
+
+        result = json.loads(response.choices[0].message.content)
+
+        if "completed_reaction" in result:
+            return result["completed_reaction"]
+
+    except Exception as exc:
+        print(f"DeepSeek API error: {exc}")
+        return None
+
+    return None
+
+
+def _analyze_reaction_completeness(reaction_text: str) -> Dict[str, Any]:
+    """Analyze if a reaction is complete or needs completion."""
+    reaction_text = reaction_text.strip()
+
+    # Check for reaction arrow
+    has_arrow = any(arrow in reaction_text for arrow in ["→", "->", "↔", "⇌"])
+
+    if not has_arrow:
+        return {"complete": False, "missing": "reaction arrow", "reason": "No reaction arrow found"}
+
+    # Split reaction
+    parts = None
+    for sep in [" → ", " -> ", " ↔ ", " ⇌ "]:
+        if sep in reaction_text:
+            parts = reaction_text.split(sep, 1)
+            break
+
+    if not parts or len(parts) != 2:
+        return {"complete": False, "missing": "proper format", "reason": "Cannot parse reaction format"}
+
+    reactants_text, products_text = parts
+
+    # Check if reactants/products exist
+    reactants = [r.strip() for r in reactants_text.split("+") if r.strip()]
+    products = [p.strip() for p in products_text.split("+") if p.strip()]
+
+    if not reactants:
+        return {"complete": False, "missing": "reactants", "reason": "No reactants found"}
+
+    if not products:
+        return {"complete": False, "missing": "products", "reason": "No products found"}
+
+    # Basic completeness check
+    if len(reactants) >= 1 and len(products) >= 1:
+        return {"complete": True, "reactants": reactants, "products": products}
+
+    return {"complete": False, "missing": "components", "reason": "Insufficient reaction components"}
+
+
+def render_reaction_svg(reaction_text: str, api_key: str = "", auto_complete: bool = False):
     reaction_text = (reaction_text or "").strip()
     if not reaction_text:
         return "", "⚠️ Enter a reaction SMILES/SMARTS string (e.g. CH4.O>>CO2)."
-    if ">>" not in reaction_text:
-        return "", "⚠️ Reaction input must include '>>' separating reactants and products."
 
-    svg = _render_smiles_to_svg(reaction_text)
-    if not svg:
-        return "", "🚨 Could not parse or render the reaction."
+    # Check if it's already SMILES format (contains >>)
+    if ">>" in reaction_text:
+        svg = _render_smiles_to_svg(reaction_text)
+        if svg:
+            status = "✅ Reaction rendered successfully from SMILES."
+            return svg, status
+        else:
+            return "", "🚨 Could not parse SMILES reaction format."
+
+    # If not SMILES and auto_complete is enabled, try to complete with DeepSeek
+    if auto_complete and api_key:
+        analysis = _analyze_reaction_completeness(reaction_text)
+        if not analysis["complete"]:
+            completed_reaction = _complete_reaction_with_deepseek(reaction_text, api_key)
+            if completed_reaction:
+                # Try to render the completed reaction
+                svg = _render_reaction_from_nist(completed_reaction)
+                if svg:
+                    status = f"✅ Reaction completed and rendered using DeepSeek AI.\nOriginal: {reaction_text}\nCompleted: {completed_reaction}"
+                    return svg, status
+                else:
+                    return "", f"🚨 DeepSeek completed reaction but rendering failed: {completed_reaction}"
+            else:
+                return "", f"🚨 Could not complete reaction with AI. Missing: {analysis.get('missing', 'unknown')}"
 
-    status = "✅ Reaction rendered successfully."
-    return svg, status
+    # Fallback: try NIST format rendering
+    svg = _render_reaction_from_nist(reaction_text)
+    if svg:
+        status = "✅ Reaction rendered from NIST format."
+        return svg, status
+
+    return "", "🚨 Could not parse or render the reaction. Try SMILES format (reactants>>products) or enable AI completion."
 
 
 def _extract_compounds_from_reaction(reaction_text: str) -> List[str]:
@@ -1218,14 +1347,35 @@ def build_interface() -> gr.Blocks:
                 with thermo_accordion:
                     thermo_data_display = gr.JSON(label="Raw Thermodynamic Data")
 
-            # Tab 3: Reaction SVG (Enhanced with NIST reactions)
+            # Tab 3: Reaction SVG (Enhanced with NIST reactions and AI completion)
             with gr.TabItem("Reaction SVG"):
                 gr.Markdown(
-                    "🎨 **Render chemical reactions as SVG using RDKit**\n\n"
-                    "Choose from NIST database reactions or enter custom SMILES/SMARTS reactions.\n\n"
-                    "Examples: `CCO.O=C=O>>CC(=O)O` or `[CH3:1].[Cl:2][C@@H](F)[Br]>>[CH3:1][C@@H](F)[Cl]`"
+                    "🎨 **Render chemical reactions as SVG using RDKit + AI Completion**\n\n"
+                    "Choose from NIST database reactions, enter custom reactions, or let AI complete partial reactions!\n\n"
+                    "**Features:**\n"
+                    "- 🧪 200+ NIST database reactions\n"
+                    "- 🤖 AI-powered reaction completion (DeepSeek)\n"
+                    "- 🔬 Multiple input formats (NIST, SMILES, SMARTS)\n"
+                    "- ⚡ Automatic format detection and conversion"
                 )
 
+                # API Key Configuration
+                with gr.Accordion("🔑 DeepSeek API Configuration", open=False):
+                    deepseek_api_key = gr.Textbox(
+                        label="DeepSeek API Key",
+                        placeholder="sk-...",
+                        type="password",
+                        info="Get your API key from https://platform.deepseek.com/"
+                    )
+                    gr.Markdown(
+                        "**How to get API key:**\n"
+                        "1. Visit https://platform.deepseek.com/\n"
+                        "2. Sign up/Login to your account\n"
+                        "3. Go to API Keys section\n"
+                        "4. Create a new API key\n"
+                        "5. Copy and paste it here"
+                    )
+
                 # NIST reactions dropdown
                 nist_reactions = _fetch_all_nist_reactions(limit=200)
                 nist_reaction_options = [("", "")] + nist_reactions if nist_reactions else []
@@ -1241,31 +1391,32 @@ def build_interface() -> gr.Blocks:
                         )
 
                         reaction_input = gr.Textbox(
-                            label="Custom Reaction SMILES/SMARTS",
-                            placeholder="Reactant1.Reactant2>>Product1.Product2",
-                            lines=3,
-                            info="Enter your own reaction in SMILES/SMARTS format"
+                            label="Custom Reaction Input",
+                            placeholder="Enter reaction in any format:\nNIST: CH4 + O2 → CO2 + H2O\nSMILES: CH4.O2>>CO2.H2O\nPartial: CH4 + O2 → (AI will complete)",
+                            lines=4,
+                            info="Supports NIST format, SMILES/SMARTS, or partial reactions"
                         )
 
                     with gr.Column():
                         render_mode = gr.Radio(
                             label="Render Mode",
-                            choices=["Auto (NIST→SMILES)", "Direct SMILES/SMARTS"],
-                            value="Auto (NIST→SMILES)",
-                            info="Auto mode converts NIST reaction format to SMILES for RDKit"
+                            choices=["Auto (detect format)", "Force NIST format", "Force SMILES/SMARTS"],
+                            value="Auto (detect format)",
+                            info="Auto mode intelligently detects and converts formats"
                         )
 
-                        render_options = gr.CheckboxGroup(
-                            label="Render Options",
-                            choices=["High quality", "Large molecules", "Color atoms"],
-                            value=["High quality"],
-                            info="Additional rendering preferences"
+                        ai_options = gr.CheckboxGroup(
+                            label="🤖 AI Enhancement",
+                            choices=["Enable AI completion", "High quality rendering", "Show completion reasoning"],
+                            value=["Enable AI completion"],
+                            info="Use DeepSeek AI to complete partial reactions"
                         )
 
                 # Buttons
                 with gr.Row():
-                    render_nist_btn = gr.Button("🎨 Render Selected NIST Reaction", variant="primary")
-                    render_custom_btn = gr.Button("🔬 Render Custom Reaction", variant="secondary")
+                    render_auto_btn = gr.Button("🚀 Smart Render (Auto-detect)", variant="primary")
+                    render_nist_btn = gr.Button("🧪 Render NIST Format", variant="secondary")
+                    render_smiles_btn = gr.Button("🔬 Render SMILES/SMARTS", variant="secondary")
                     clear_btn = gr.Button("🗑️ Clear", variant="stop")
 
                 # Output
@@ -1285,54 +1436,91 @@ def build_interface() -> gr.Blocks:
                     outputs=reaction_input,
                 )
 
-                # Render NIST reaction
+                # Smart auto-render function
+                def render_auto_reaction(reaction_text, api_key, ai_options, render_mode):
+                    if not reaction_text:
+                        return "", "⚠️ Please enter a reaction or select from the NIST dropdown."
+
+                    status_prefix = ""
+                    final_reaction = reaction_text
+
+                    # Check if AI completion is enabled and reaction might be incomplete
+                    if "Enable AI completion" in (ai_options or []) and api_key:
+                        analysis = _analyze_reaction_completeness(reaction_text)
+                        if not analysis["complete"]:
+                            completed_reaction = _complete_reaction_with_deepseek(reaction_text, api_key)
+                            if completed_reaction:
+                                final_reaction = completed_reaction
+                                status_prefix = f"🤖 **AI Completed Reaction**\nOriginal: {reaction_text}\nCompleted: {final_reaction}\n\n"
+
+                    # Render based on detected format or forced mode
+                    if render_mode == "Force SMILES/SMARTS" or (render_mode == "Auto (detect format)" and ">>" in final_reaction):
+                        svg = _render_smiles_to_svg(final_reaction)
+                        render_type = "SMILES/SMARTS"
+                    elif render_mode == "Force NIST format" or render_mode == "Auto (detect format)":
+                        svg = _render_reaction_from_nist(final_reaction)
+                        render_type = "NIST format"
+                    else:
+                        # Try both formats
+                        svg = _render_reaction_from_nist(final_reaction)
+                        if not svg:
+                            svg = _render_smiles_to_svg(final_reaction)
+                        render_type = "auto-detected"
+
+                    if svg:
+                        quality_note = " (High quality)" if "High quality rendering" in (ai_options or []) else ""
+                        status = f"{status_prefix}✅ Successfully rendered as {render_type}{quality_note}"
+                        return svg, status
+                    else:
+                        return "", f"{status_prefix}❌ Could not render reaction. Try a different format or check syntax: {final_reaction[:100]}..."
+
+                # Legacy render functions (kept for compatibility)
                 def render_nist_reaction(reaction_text, options):
                     if not reaction_text:
                         return "", "⚠️ Please select a reaction from the dropdown or enter a custom reaction."
 
-                    try:
-                        svg = _render_reaction_from_nist(reaction_text)
-                        if svg:
-                            status = f"✅ Successfully rendered NIST reaction: {reaction_text[:100]}..."
-                            if "High quality" in (options or []):
-                                status += " (High quality mode)"
-                            return svg, status
-                        else:
-                            return "", f"❌ Could not render reaction. The reaction format may not be supported by RDKit: {reaction_text[:100]}..."
-                    except Exception as exc:
-                        return "", f"🚨 Error rendering reaction: {exc}"
-
-                # Render custom SMILES reaction
-                def render_custom_reaction(reaction_text, options):
+                    svg = _render_reaction_from_nist(reaction_text)
+                    if svg:
+                        status = f"✅ Successfully rendered NIST reaction: {reaction_text[:100]}..."
+                        if "High quality" in (options or []):
+                            status += " (High quality mode)"
+                        return svg, status
+                    else:
+                        return "", f"❌ Could not render reaction. The reaction format may not be supported by RDKit: {reaction_text[:100]}..."
+
+                def render_smiles_reaction(reaction_text, options):
                     if not reaction_text:
                         return "", "⚠️ Please enter a reaction in SMILES/SMARTS format."
 
-                    try:
-                        svg = _render_smiles_to_svg(reaction_text)
-                        if svg:
-                            status = f"✅ Successfully rendered custom reaction: {reaction_text[:100]}..."
-                            if "High quality" in (options or []):
-                                status += " (High quality mode)"
-                            return svg, status
-                        else:
-                            return "", f"❌ Could not parse reaction. Please check your SMILES/SMARTS format: {reaction_text[:100]}..."
-                    except Exception as exc:
-                        return "", f"🚨 Error rendering reaction: {exc}"
+                    svg = _render_smiles_to_svg(reaction_text)
+                    if svg:
+                        status = f"✅ Successfully rendered SMILES reaction: {reaction_text[:100]}..."
+                        if "High quality" in (options or []):
+                            status += " (High quality mode)"
+                        return svg, status
+                    else:
+                        return "", f"❌ Could not parse reaction. Please check your SMILES/SMARTS format: {reaction_text[:100]}..."
 
                 # Clear function
                 def clear_outputs():
                     return "", "", ""
 
                 # Button handlers
+                render_auto_btn.click(
+                    fn=render_auto_reaction,
+                    inputs=[reaction_input, deepseek_api_key, ai_options, render_mode],
+                    outputs=[reaction_svg_output, render_status],
+                )
+
                 render_nist_btn.click(
                     fn=render_nist_reaction,
-                    inputs=[reaction_input, render_options],
+                    inputs=[reaction_input, ai_options],
                     outputs=[reaction_svg_output, render_status],
                 )
 
-                render_custom_btn.click(
-                    fn=render_custom_reaction,
-                    inputs=[reaction_input, render_options],
+                render_smiles_btn.click(
+                    fn=render_smiles_reaction,
+                    inputs=[reaction_input, ai_options],
                     outputs=[reaction_svg_output, render_status],
                 )
 

requirements.txt

@@ -10,3 +10,4 @@ fastapi
 uvicorn
 plotly
 pandas
+openai