update

.env

@@ -0,0 +1,9 @@
+# Environment variables for FastAPI TextGen
+# Copy this file to .env and fill in your actual values
+
+# OpenAI API Configuration
+OPENAI_API_KEY=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
+# Development Notes:
+# - Get your OpenAI API key from: https://platform.openai.com/api-keys
+# - Make sure your API key has sufficient credits
+# - Keep your API key secure and never commit it to version control 

.gitignore

@@ -0,0 +1 @@
+.researcher

Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.10.9
+
+COPY . .
+
+WORKDIR /
+
+RUN pip install --no-cache-dir --upgrade -r /requirements.txt
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -6,7 +6,205 @@ colorTo: indigo
 sdk: docker
 pinned: false
 license: mit
-short_description: Research agent for cientific discovery
+short_description: Simple FastAPI agent for answering questions using OpenAI
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# FastAPI TextGen with OpenAI
+
+A simple FastAPI application that uses OpenAI's LLM to answer user questions through LangChain.
+
+## 🚀 Quick Start
+
+### Local Development
+
+1. **Clone and setup**
+   ```bash
+   git clone <your-repo>
+   cd researcher
+   ```
+
+2. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Setup environment**
+   ```bash
+   # Copy the environment template
+   cp env_template.txt .env
+   
+   # Edit .env and add your OpenAI API key
+   # OPENAI_API_KEY=your_actual_key_here
+   ```
+
+4. **Run development server**
+   ```bash
+   # Option 1: Use the development runner (recommended)
+   python dev_run.py
+   
+   # Option 2: Run directly with uvicorn
+   uvicorn app:app --host 127.0.0.1 --port 8000 --reload
+   ```
+
+5. **Test the application**
+   - **Web Interface**: http://localhost:8000 (Beautiful UI for testing)
+   - **API Documentation**: http://localhost:8000/docs (Swagger UI)
+   - **Health Check**: http://localhost:8000/health
+
+### For Hugging Face Deployment
+
+In your Hugging Face Space settings, add the following secret:
+- **Name**: `OPENAI_API_KEY`
+
+## 🔗 API Endpoints
+
+The FastAPI backend provides the following endpoints for consuming the service:
+
+### Base URL
+- **Local Development**: `http://localhost:8000`
+- **Hugging Face Deployment**: `https://your-space-name.hf.space`
+
+### Available Endpoints
+
+#### 1. **GET /** - Home/Web Interface
+- **Description**: Serves the web interface for interactive testing
+- **URL**: `/`
+- **Method**: `GET`
+- **Response**: HTML page or JSON welcome message
+
+#### 2. **GET /health** - Health Check
+- **Description**: Check if the API is running and properly configured
+- **URL**: `/health`
+- **Method**: `GET`
+- **Response**:
+```json
+{
+  "status": "healthy",
+  "message": "FastAPI TextGen is running",
+  "openai_configured": true
+}
+```
+
+#### 3. **POST /api/generate** - Generate Answer
+- **Description**: Send a question and receive an AI-generated answer
+- **URL**: `/api/generate`
+- **Method**: `POST`
+- **Content-Type**: `application/json`
+- **Request Body**:
+```json
+{
+  "question": "Your question here"
+}
+```
+- **Response**:
+```json
+{
+  "text": "AI-generated answer to your question"
+}
+```
+- **Error Responses**:
+  - `400 Bad Request`: Empty or missing question
+  - `500 Internal Server Error`: OpenAI API issues or configuration problems
+
+#### 4. **GET /docs** - API Documentation
+- **Description**: Interactive Swagger UI documentation
+- **URL**: `/docs`
+- **Method**: `GET`
+- **Response**: Interactive API documentation interface
+
+## 📖 API Usage Examples
+
+### POST /api/generate
+
+Send a question to get an AI-powered answer.
+
+**Request Body:**
+```json
+{
+  "question": "What is artificial intelligence?"
+}
+```
+
+**Response:**
+```json
+{
+  "text": "Artificial intelligence (AI) refers to the simulation of human intelligence in machines..."
+}
+```
+
+### Example with curl
+```bash
+curl -X POST "http://localhost:8000/api/generate" \
+  -H "Content-Type: application/json" \
+  -d '{"question": "Explain quantum computing in simple terms"}'
+```
+
+### Example with Python
+```python
+import requests
+
+response = requests.post(
+    "http://localhost:8000/api/generate",
+    json={"question": "What is machine learning?"}
+)
+print(response.json()["text"])
+```
+
+### Example with JavaScript/Fetch
+```javascript
+async function askQuestion(question) {
+    const response = await fetch('http://localhost:8000/api/generate', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ question: question })
+    });
+    
+    const data = await response.json();
+    return data.text;
+}
+
+// Usage
+askQuestion("Explain neural networks").then(answer => {
+    console.log(answer);
+});
+```
+
+### Example with Node.js
+```javascript
+const axios = require('axios');
+
+async function askQuestion(question) {
+    try {
+        const response = await axios.post('http://localhost:8000/api/generate', {
+            question: question
+        });
+        return response.data.text;
+    } catch (error) {
+        console.error('Error:', error.response?.data || error.message);
+    }
+}
+
+// Usage
+askQuestion("What is artificial intelligence?").then(answer => {
+    console.log(answer);
+});
+```
+
+### Health Check Example
+```bash
+# Check if the API is running
+curl http://localhost:8000/health
+
+# Expected response:
+# {"status":"healthy","message":"FastAPI TextGen is running","openai_configured":true}
+```
+
+## 🌐 Integration Notes
+
+- **CORS Enabled**: The API accepts requests from any origin (`*`)
+- **Content-Type**: Always use `application/json` for POST requests
+- **Error Handling**: Check HTTP status codes and response messages
+- **Rate Limiting**: Depends on your OpenAI API key limits
+- **Timeout**: Consider setting appropriate timeouts for your requests

TextGen/ConfigEnv.py

@@ -0,0 +1,15 @@
+"""Config class for handling env variables.
+"""
+from functools import lru_cache
+from pydantic import BaseSettings
+
+class Settings(BaseSettings):
+    OPENAI_API_KEY: str
+    
+    class Config:
+        env_file = '.env'
+
+@lru_cache()
+def get_settings():
+    return Settings()
+config = get_settings()

TextGen/__init__.py

@@ -0,0 +1,7 @@
+from fastapi import FastAPI
+
+app = FastAPI(title="Deploying FastAPI Apps on Huggingface")
+
+from TextGen import router
+
+

TextGen/router.py

@@ -0,0 +1,82 @@
+from pydantic import BaseModel
+from fastapi import HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+import os
+
+from .ConfigEnv import config
+from fastapi.middleware.cors import CORSMiddleware
+
+from langchain_openai import OpenAI
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+from TextGen import app
+
+class Generate(BaseModel):
+    text: str
+
+class QuestionRequest(BaseModel):
+    question: str
+
+def answer_question(question: str):
+    if not question or question.strip() == "":
+        raise HTTPException(status_code=400, detail="Please provide a question.")
+    
+    # Simple prompt template for answering questions
+    prompt_template = PromptTemplate(
+        template="Answer the following question clearly and concisely: {question}",
+        input_variables=["question"]
+    )
+
+    # Initialize OpenAI LLM
+    llm = OpenAI(
+        api_key=config.OPENAI_API_KEY,
+        temperature=0.7
+    )
+
+    # Create LLM chain
+    llm_chain = LLMChain(
+        prompt=prompt_template,
+        llm=llm
+    )
+
+    try:
+        # Generate response
+        response = llm_chain.run(question=question)
+        return Generate(text=response.strip())
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating response: {str(e)}")
+
+# Mount static files for development interface
+if os.path.exists("static"):
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/", tags=["Home"])
+def api_home():
+    # Check if we have the static file for development interface
+    if os.path.exists("static/index.html"):
+        return FileResponse('static/index.html')
+    else:
+        return {'detail': 'Welcome to FastAPI TextGen Tutorial! Visit /docs for API documentation.'}
+
+@app.get("/health", tags=["Health"])
+def health_check():
+    """Health check endpoint for development and deployment monitoring."""
+    return {
+        "status": "healthy",
+        "message": "FastAPI TextGen is running",
+        "openai_configured": bool(config.OPENAI_API_KEY)
+    }
+
+@app.post("/api/generate", summary="Answer user questions", tags=["Generate"], response_model=Generate)
+def inference(request: QuestionRequest):
+    return answer_question(question=request.question)

app.py

@@ -0,0 +1 @@
+from TextGen import app

dev_run.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+Development runner for the FastAPI TextGen application.
+This script helps run the application locally with development configurations.
+"""
+
+import os
+import sys
+import uvicorn
+from pathlib import Path
+
+def setup_environment():
+    """Setup environment variables for local development."""
+    # Check if .env file exists
+    env_file = Path(".env")
+    if not env_file.exists():
+        print("⚠️  No .env file found!")
+        print("📝 Please create a .env file with the following content:")
+        print()
+        print("OPENAI_API_KEY=your_openai_api_key_here")
+        print()
+        
+        # Ask user if they want to continue with environment variable
+        openai_key = os.getenv("OPENAI_API_KEY")
+        if not openai_key:
+            print("❌ OPENAI_API_KEY environment variable not set either.")
+            print("Please either:")
+            print("1. Create a .env file with OPENAI_API_KEY=your_key")
+            print("2. Set the environment variable: export OPENAI_API_KEY=your_key")
+            sys.exit(1)
+        else:
+            print("✅ Found OPENAI_API_KEY in environment variables")
+    else:
+        print("✅ Found .env file")
+
+def main():
+    """Main function to run the development server."""
+    print("🚀 Starting FastAPI TextGen Development Server")
+    print("=" * 50)
+    
+    # Setup environment
+    setup_environment()
+    
+    print("🔧 Development server starting...")
+    print("📍 API will be available at: http://localhost:8000")
+    print("📚 API documentation at: http://localhost:8000/docs")
+    print("🔄 Auto-reload enabled for development")
+    print()
+    print("Press Ctrl+C to stop the server")
+    print("=" * 50)
+    
+    # Run the development server
+    try:
+        uvicorn.run(
+            "app:app",
+            host="127.0.0.1",
+            port=8000,
+            reload=True,
+            log_level="info"
+        )
+    except KeyboardInterrupt:
+        print("\n👋 Development server stopped")
+
+if __name__ == "__main__":
+    main() 

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.99.1
+uvicorn
+requests
+pydantic==1.10.12
+langchain
+langchain-openai
+openai
+python-multipart
+python-dotenv

static/index.html

@@ -0,0 +1,248 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FastAPI TextGen - Development Interface</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Arial', sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 15px;
+            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+            overflow: hidden;
+        }
+        
+        .header {
+            background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+            color: white;
+            padding: 30px;
+            text-align: center;
+        }
+        
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+        }
+        
+        .header p {
+            font-size: 1.1em;
+            opacity: 0.9;
+        }
+        
+        .content {
+            padding: 40px;
+        }
+        
+        .form-group {
+            margin-bottom: 25px;
+        }
+        
+        label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: bold;
+            color: #333;
+        }
+        
+        #questionInput {
+            width: 100%;
+            padding: 15px;
+            border: 2px solid #e1e5e9;
+            border-radius: 8px;
+            font-size: 16px;
+            transition: border-color 0.3s;
+            resize: vertical;
+            min-height: 100px;
+        }
+        
+        #questionInput:focus {
+            outline: none;
+            border-color: #4facfe;
+        }
+        
+        #askButton {
+            background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+            color: white;
+            padding: 15px 30px;
+            border: none;
+            border-radius: 8px;
+            font-size: 18px;
+            cursor: pointer;
+            transition: transform 0.2s;
+            width: 100%;
+        }
+        
+        #askButton:hover {
+            transform: translateY(-2px);
+        }
+        
+        #askButton:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+            transform: none;
+        }
+        
+        .response-section {
+            margin-top: 30px;
+        }
+        
+        #responseContainer {
+            background: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 8px;
+            padding: 20px;
+            min-height: 100px;
+            white-space: pre-wrap;
+            line-height: 1.6;
+        }
+        
+        .loading {
+            text-align: center;
+            color: #6c757d;
+            font-style: italic;
+        }
+        
+        .error {
+            color: #dc3545;
+            background: #f8d7da;
+            border-color: #f5c6cb;
+        }
+        
+        .examples {
+            margin-top: 20px;
+            padding: 20px;
+            background: #e3f2fd;
+            border-radius: 8px;
+        }
+        
+        .examples h3 {
+            color: #1976d2;
+            margin-bottom: 15px;
+        }
+        
+        .example-question {
+            background: white;
+            padding: 10px;
+            margin: 5px 0;
+            border-radius: 5px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        
+        .example-question:hover {
+            background: #f5f5f5;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🤖 FastAPI TextGen</h1>
+            <p>Development Interface - Ask any question!</p>
+        </div>
+        
+        <div class="content">
+            <form id="questionForm">
+                <div class="form-group">
+                    <label for="questionInput">Your Question:</label>
+                    <textarea 
+                        id="questionInput" 
+                        placeholder="Ask me anything... For example: 'What is artificial intelligence?' or 'Explain quantum computing in simple terms'"
+                        required
+                    ></textarea>
+                </div>
+                
+                <button type="submit" id="askButton">Ask Question</button>
+            </form>
+            
+            <div class="response-section">
+                <label>Response:</label>
+                <div id="responseContainer">
+                    Ready to answer your questions! Type a question above and click "Ask Question".
+                </div>
+            </div>
+            
+            <div class="examples">
+                <h3>💡 Example Questions</h3>
+                <div class="example-question" onclick="setQuestion('What is machine learning?')">
+                    What is machine learning?
+                </div>
+                <div class="example-question" onclick="setQuestion('Explain the difference between AI and machine learning')">
+                    Explain the difference between AI and machine learning
+                </div>
+                <div class="example-question" onclick="setQuestion('How does a neural network work?')">
+                    How does a neural network work?
+                </div>
+                <div class="example-question" onclick="setQuestion('What are the benefits of cloud computing?')">
+                    What are the benefits of cloud computing?
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const questionForm = document.getElementById('questionForm');
+        const questionInput = document.getElementById('questionInput');
+        const askButton = document.getElementById('askButton');
+        const responseContainer = document.getElementById('responseContainer');
+
+        function setQuestion(question) {
+            questionInput.value = question;
+            questionInput.focus();
+        }
+
+        questionForm.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            const question = questionInput.value.trim();
+            if (!question) return;
+
+            // Show loading state
+            askButton.disabled = true;
+            askButton.textContent = 'Thinking...';
+            responseContainer.className = 'loading';
+            responseContainer.textContent = '🤔 Processing your question...';
+
+            try {
+                const response = await fetch('/api/generate', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ question: question }),
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    responseContainer.className = '';
+                    responseContainer.textContent = data.text;
+                } else {
+                    throw new Error(data.detail || 'Something went wrong');
+                }
+            } catch (error) {
+                responseContainer.className = 'error';
+                responseContainer.textContent = `Error: ${error.message}`;
+            } finally {
+                askButton.disabled = false;
+                askButton.textContent = 'Ask Question';
+            }
+        });
+    </script>
+</body>
+</html> 

test_api.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+Simple test script for the FastAPI TextGen API.
+Run this script to test the API endpoints locally.
+"""
+
+import requests
+import json
+import sys
+
+def test_health_endpoint(base_url):
+    """Test the health check endpoint."""
+    print("🔍 Testing health endpoint...")
+    try:
+        response = requests.get(f"{base_url}/health")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ Health check passed: {data['message']}")
+            print(f"🔑 OpenAI configured: {data['openai_configured']}")
+            return True
+        else:
+            print(f"❌ Health check failed with status: {response.status_code}")
+            return False
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Health check failed: {e}")
+        return False
+
+def test_generate_endpoint(base_url, question):
+    """Test the generate endpoint with a question."""
+    print(f"\n💭 Testing question: '{question}'")
+    try:
+        response = requests.post(
+            f"{base_url}/api/generate",
+            json={"question": question},
+            headers={"Content-Type": "application/json"}
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            print("✅ Response received:")
+            print(f"📝 Answer: {data['text'][:200]}{'...' if len(data['text']) > 200 else ''}")
+            return True
+        else:
+            print(f"❌ Request failed with status: {response.status_code}")
+            print(f"📄 Response: {response.text}")
+            return False
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Request failed: {e}")
+        return False
+
+def main():
+    """Main test function."""
+    base_url = "http://localhost:8000"
+    
+    print("🚀 FastAPI TextGen API Test Suite")
+    print("=" * 50)
+    
+    # Test health endpoint
+    if not test_health_endpoint(base_url):
+        print("\n❌ Health check failed. Make sure the server is running.")
+        print("💡 Start the server with: python dev_run.py")
+        sys.exit(1)
+    
+    # Test questions
+    test_questions = [
+        "What is artificial intelligence?",
+        "Explain Python programming in one sentence",
+        "What are the benefits of renewable energy?",
+    ]
+    
+    print(f"\n🧪 Testing {len(test_questions)} questions...")
+    
+    success_count = 0
+    for question in test_questions:
+        if test_generate_endpoint(base_url, question):
+            success_count += 1
+    
+    print(f"\n📊 Test Results: {success_count}/{len(test_questions)} tests passed")
+    
+    if success_count == len(test_questions):
+        print("🎉 All tests passed! Your API is working correctly.")
+    else:
+        print("⚠️  Some tests failed. Check your OpenAI API key and configuration.")
+
+if __name__ == "__main__":
+    main()