Add application file

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11.8-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the FastAPI app
+COPY ./app /app
+
+# Expose Hugging Face-required port
+EXPOSE 7860
+
+# Run the app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,12 @@
----
-title: Planify
-emoji: 🐠
-colorFrom: yellow
-colorTo: blue
-sdk: docker
-pinned: false
-license: unknown
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: BP FastAPI
+emoji: 📈
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+license: other
+short_description: Fast API Business Plan Generator
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/main.py

@@ -0,0 +1,254 @@
+##########################
+        #NEW TEST#
+##########################
+import os
+import asyncio
+import logging
+from typing import List, Dict, Any, Optional
+
+from dotenv import load_dotenv
+load_dotenv()  # Load environment variables from .env into os.environ
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+# Import LangChain components
+from langchain_community.chat_models import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+# Import the base LLM class to build our custom wrapper
+from langchain.llms.base import LLM
+
+from huggingface_hub import InferenceClient
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+
+# Create the FastAPI app
+app = FastAPI()
+
+# Allow all origins (adjust for production usage)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Fixed list of business questions (order matters)
+QUESTIONS = [
+    "What is your business name?",
+    "What product or service do you offer?",
+    "Who is your target customer?",
+    "What problem does your business solve?",
+    "Who are your competitors?",
+    "What is your unique value proposition?",
+    "What is your pricing strategy?",
+    "What are your short-term goals?",
+    "What are your long-term goals?",
+    "How will you acquire customers?",
+]
+
+# Data model for incoming business plan generation requests
+class GenerateRequest(BaseModel):
+    answers: List[str]
+    model: str
+
+def generate_model_output(model: str, provider: str, api_key: str, prompt: str, max_tokens: int = 500) -> str:
+    """
+    A helper function that wraps the Hugging Face Inference API call.
+    """
+    client = InferenceClient(provider=provider, api_key=api_key)
+    completion = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=max_tokens,
+    )
+    return completion.choices[0].message.content
+
+###############################################################################
+# HFInferenceLLM: A wrapper for Hugging Face models that matches the LLM interface.
+###############################################################################
+class HFInferenceLLM(LLM):
+    model: str
+    provider: str
+    api_key: str
+    max_tokens: int
+
+    def __init__(self, model: str, provider: str = "hf-inference", api_key: str = "", max_tokens: int = 500):
+        self.model = model
+        self.provider = provider
+        self.api_key = api_key
+        self.max_tokens = max_tokens
+
+    @property
+    def _llm_type(self) -> str:
+        return "hf_inference"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        """
+        Calls the Hugging Face API using the provided prompt.
+        The `stop` parameter is not implemented (or forwarded) here.
+        """
+        return generate_model_output(
+            model=self.model,
+            provider=self.provider,
+            api_key=self.api_key,
+            prompt=prompt,
+            max_tokens=self.max_tokens
+        )
+
+    def get_num_tokens(self, prompt: str) -> int:
+        """
+        A simple implementation that counts tokens as space-separated words.
+        You may replace this with a more accurate token counter.
+        """
+        return len(prompt.split())
+
+###############################################################################
+# get_llm: Return an LLM instance based on the selected model.
+###############################################################################
+def get_llm(model_name: str):
+    hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    if model_name == "GPT":
+        return ChatOpenAI(model_name="gpt-4o-mini-2024-07-18", temperature=0.7)
+    elif model_name == "Llama":
+        # Use the appropriate Llama model identifier.
+        return HFInferenceLLM(
+            model="huggyllama/llama-2",  # <-- change this to your desired Llama model
+            provider="hf-inference",
+            api_key=hf_token,
+            max_tokens=500
+        )
+    elif model_name == "Qwen-2.5":
+        return HFInferenceLLM(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            provider="hf-inference",
+            api_key=hf_token,
+            max_tokens=500
+        )
+    elif model_name == "Mistral":
+        return HFInferenceLLM(
+            model="mistralai/Mistral-7B-Instruct-v0.3",
+            provider="hf-inference",
+            api_key=hf_token,
+            max_tokens=500
+        )
+    else:
+        # Default to GPT if the provided model name is unrecognized.
+        return ChatOpenAI(model_name="gpt-4o-mini-2024-07-18", temperature=0.7)
+
+###############################################################################
+# FastAPI Endpoints
+###############################################################################
+
+@app.get("/suggestions", response_model=List[Dict[str, Any]])
+async def get_suggestions() -> List[Dict[str, Any]]:
+    """
+    For each fixed business question, generate three concise bullet-point suggestions.
+    This endpoint uses gpt-4o-mini-2024-07-18 via LangChain.
+    """
+    suggestions_list = []
+    
+    suggestion_template_str = (
+        "For the following business question, provide exactly 3 concise bullet-point suggestions or name suggestions if it fits the question. "
+        "Do not include any extra text.\n\nQuestion: \"{question}\"\n\nSuggestions:\n-"
+    )
+    suggestion_prompt = PromptTemplate(
+        input_variables=["question"],
+        template=suggestion_template_str
+    )
+    
+    # Use ChatOpenAI (gpt-4o-mini-2024-07-18) to generate suggestions.
+    suggestion_chain = LLMChain(
+        llm=ChatOpenAI(model_name="gpt-4o-mini-2024-07-18", temperature=0.7), 
+        prompt=suggestion_prompt
+    )
+    
+    for question in QUESTIONS:
+        try:
+            raw_text = await asyncio.to_thread(suggestion_chain.run, {"question": question})
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+        suggestion_array = [
+            line.replace("-", "").strip() for line in raw_text.split("\n") if line.strip()
+        ]
+        suggestions_list.append({"question": question, "suggestions": suggestion_array})
+    
+    return suggestions_list
+
+@app.post("/generate")
+async def generate_business_plan(data: GenerateRequest):
+    """
+    Combine the questionnaire answers with their corresponding questions,
+    build a detailed Markdown prompt, and generate a full business plan using
+    the selected model.
+    """
+    if len(data.answers) != len(QUESTIONS):
+        raise HTTPException(status_code=400, detail="Expected exactly 10 answers.")
+    
+    q_and_a = "\n".join(
+        [f"{idx+1}. {question}: {data.answers[idx]}" for idx, question in enumerate(QUESTIONS)]
+    )
+    
+    plan_template_str = (
+        "Based on the following responses to business questions:\n"
+        "{q_and_a}\n\n"
+        "Generate a detailed business plan in Markdown format. Your response must include exactly the following sections and subheadings using proper Markdown syntax:\n\n"
+        "## Executive Summary\n"
+        "Provide a brief summary of the business, its purpose, and key objectives.\n\n"
+        "## Market Analysis\n"
+        "### Industry Overview\n"
+        "Describe the overall industry trends and market dynamics.\n\n"
+        "### Target Market\n"
+        "Define the primary target audience, including demographics and psychographics.\n\n"
+        "### Competitive Analysis\n"
+        "Analyze the competitive landscape and explain what differentiates the business from competitors.\n\n"
+        "## Operations Plan\n"
+        "### Location\n"
+        "Specify the business location(s) and rationale for the choice.\n\n"
+        "### Distribution\n"
+        "Explain the distribution channels and logistics plan for delivering the product or service.\n\n"
+        "### Staffing\n"
+        "Outline the staffing requirements and key roles necessary for operations.\n\n"
+        "## Financial Plan\n"
+        "### Revenue Streams\n"
+        "Identify the primary and secondary sources of revenue.\n\n"
+        "### Cost Structure\n"
+        "Detail the major cost components and how costs will be managed.\n\n"
+        "### Funding Requirements\n"
+        "Specify the funding needed to launch and sustain the business.\n\n"
+        "### Profitability\n"
+        "Outline the financial projections and timeline to profitability.\n\n"
+        "## Conclusion\n"
+        "Summarize the vision, key takeaways, and future direction of the business.\n\n"
+        "Follow this template exactly, and be concise."
+    )
+    
+    plan_prompt = PromptTemplate(
+        input_variables=["q_and_a"],
+        template=plan_template_str
+    )
+    
+    # Get the LLM instance based on the selected model.
+    llm_selected = get_llm(data.model)
+    plan_chain = LLMChain(llm=llm_selected, prompt=plan_prompt)
+    
+    logging.info("Generated prompt for business plan:\n" + plan_template_str.format(q_and_a=q_and_a))
+    
+    try:
+        full_plan = await asyncio.to_thread(plan_chain.run, {"q_and_a": q_and_a})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    return {
+        "summary": "Generated Business Plan",
+        "plan": full_plan,
+    }
+
+@app.get("/")
+def root():
+    return {"status": "FastAPI is running 🚀"}

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+httpx
+langchain[community]
+langgraph
+openai
+pydantic
+loguru
+python-dotenv
+huggingface_hub
+langchain-community>=0.2.0
+