Upload folder using huggingface_hub

Dockerfile

@@ -2,20 +2,12 @@ FROM python:3.12-slim
 
 WORKDIR /app
 
-# Install git for git dependencies, then install uv
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
-RUN pip install uv
+# Install only what we need - lightweight and fast
+RUN pip install fastapi uvicorn httpx pydantic
 
-# Copy the ACE repository and our FastAPI files
-COPY . /app
-
-# Install ACE framework using uv (referencing the local pyproject.toml in the cloned repo)
-# and install FastAPI components + boto3 for pydantic-ai bedrock support
-RUN uv pip install --system fastapi uvicorn pydantic litellm boto3
-# Since the cloned directory has pyproject.toml, we can install the local package
-RUN uv pip install --system -e .
+# Copy our application
+COPY main.py .
 
 EXPOSE 7860
 
-# We need the user to pass API keys in Space Secrets (e.g. OPENAI_API_KEY, GROQ_API_KEY)
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -1,16 +1,10 @@
-from fastapi import FastAPI, Request, HTTPException
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import os
-import json
-import asyncio
+import httpx
 
-# Import ACE from the cloned agentic-context-engine directory
-import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), "src"))
-from ace import ACELiteLLM
-
-app = FastAPI(title="Logic Engine with ACE")
+app = FastAPI(title="Logic Engine")
 
 app.add_middleware(
     CORSMiddleware,
@@ -22,39 +16,49 @@ app.add_middleware(
 
 class ChatRequest(BaseModel):
     prompt: str
-    model: str = "gpt-4o-mini" # Or any openrouter/nim model supported by LiteLLM
-
-# Configuration for Node 1 (Redis) and External Tools
-REDIS_URL = os.environ.get("REDIS_URL", "https://augment17-redis-memory-core.hf.space")
-VECTOR_DB_URL = os.environ.get("VECTOR_DB_URL", "")
-
-# Initialize ACE agent (using LiteLLM under the hood to support 100+ providers)
-agent = ACELiteLLM(model=os.environ.get("DEFAULT_MODEL", "gpt-4o-mini"))
+    model: str = "gpt-4o-mini"
 
 @app.post("/chat")
 async def chat_endpoint(request: ChatRequest):
+    api_key = os.environ.get("OPENAI_API_KEY") or os.environ.get("GROQ_API_KEY")
+
+    if not api_key:
+        # Graceful fallback when no API key is configured
+        return {
+            "response": (
+                f"[Logic Engine] Received your message: \"{request.prompt}\"\n\n"
+                "No LLM API key is configured yet. Please add OPENAI_API_KEY or GROQ_API_KEY "
+                "via the Providers panel in the UI or in the Space Secrets settings on Hugging Face."
+            ),
+            "doc": True
+        }
+
     try:
-        # Step 1: Use GitNexus tool (mocked via prompt injection for now) to sync latest repo state
-        repo_context = "GitNexus Synced: Repository 'kilo-code' is up to date."
-        
-        # Step 2: Use Tree-sitter AST Graph (mocked)
-        ast_context = "AST Graph: Found 3 dependent files in Redis Node 1."
-        
-        # Build enriched prompt
-        enriched_prompt = f"System Context:\n{repo_context}\n{ast_context}\n\nUser Request:\n{request.prompt}"
-        
-        # Step 3: Run ACE agent.ask()
-        # ACE automatically checks its Skillbook (which can be backed by Redis) for past learnings
-        response = agent.ask(enriched_prompt)
-        
-        # Step 4: After execution, trigger async reflection to learn from this trace
-        # agent.learn_from_traces(...)
-        
-        return {"response": response, "doc": True}
-        
+        # Use OpenAI-compatible API via httpx (works with OpenAI & Groq)
+        base_url = "https://api.groq.com/openai/v1" if os.environ.get("GROQ_API_KEY") else "https://api.openai.com/v1"
+        chosen_key = os.environ.get("GROQ_API_KEY") or os.environ.get("OPENAI_API_KEY")
+        model = "llama-3.1-8b-instant" if os.environ.get("GROQ_API_KEY") else request.model
+
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.post(
+                f"{base_url}/chat/completions",
+                headers={"Authorization": f"Bearer {chosen_key}", "Content-Type": "application/json"},
+                json={
+                    "model": model,
+                    "messages": [
+                        {"role": "system", "content": "You are Manus, a helpful autonomous AI agent."},
+                        {"role": "user", "content": request.prompt}
+                    ]
+                }
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            reply = data["choices"][0]["message"]["content"]
+            return {"response": reply, "doc": True}
+
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/health")
 def health():
-    return {"status": "ACE Logic Engine Running"}
+    return {"status": "Logic Engine Running"}