fastapi-spawn 0.2.0__tar.gz → 0.3.0__tar.gz

{fastapi_spawn-0.2.0 → fastapi_spawn-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-spawn
-Version: 0.2.0
+Version: 0.3.0
 Summary: A powerful CLI tool to scaffold production-ready FastAPI projects with flexible database, auth, broker, and deployment options.
 Project-URL: Homepage, https://github.com/Bishwajitgarai/fastapi-spawn
 Project-URL: Documentation, https://github.com/Bishwajitgarai/fastapi-spawn#readme

{fastapi_spawn-0.2.0 → fastapi_spawn-0.3.0}/fastapi_spawn/__init__.py

@@ -1,6 +1,6 @@
 """fastapi-spawn — Production-ready FastAPI project scaffolding CLI."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __author__ = "Bishwajit Garai"
 __email__ = "bishwajitgarai@gmail.com"
 __license__ = "MIT"

{fastapi_spawn-0.2.0 → fastapi_spawn-0.3.0}/fastapi_spawn/config.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 
 from fastapi_spawn.constants import (
-    AIProvider, AuthType, Broker, Cache, CIProvider,
+    AIProvider, APIExtra, AuthType, Broker, Cache, CIProvider,
     Database, EmailProvider, LogDestination, LogLibrary,
     MigrationTool, MonitoringProvider, NotificationProvider,
     ORM, Stack, Storage, VectorDB,
@@ -39,6 +39,8 @@ class ProjectConfig:
     # Deployment
     stack: Stack = Stack.standard
     ci: CIProvider = CIProvider.github
+    # API extras
+    api_extra: APIExtra = APIExtra.none
     # Flags
     include_docker: bool = True
     include_tests: bool = True
@@ -135,6 +137,14 @@ class ProjectConfig:
     def has_log_file(self) -> bool:
         return self.log_dest in (LogDestination.local, LogDestination.cloudwatch, LogDestination.datadog)
 
+    @property
+    def has_websockets(self) -> bool:
+        return self.api_extra in (APIExtra.websockets, APIExtra.both)
+
+    @property
+    def has_graphql(self) -> bool:
+        return self.api_extra in (APIExtra.graphql, APIExtra.both)
+
     # ── Template context ───────────────────────────────────────────────────
 
     def to_context(self) -> dict:
@@ -159,6 +169,9 @@ class ProjectConfig:
             "stack": self.stack.value,
             "ci": self.ci.value,
             # booleans
+            "api_extra": self.api_extra.value,
+            "has_websockets": self.has_websockets,
+            "has_graphql": self.has_graphql,
             "has_relational_db": self.has_relational_db,
             "has_mongo": self.has_mongo,
             "has_auth": self.has_auth,
@@ -203,6 +216,7 @@ class ProjectConfig:
             ("Log dest",     self.log_dest.value),
             ("Stack",        self.stack.value),
             ("CI/CD",        self.ci.value),
+            ("API extras",   self.api_extra.value),
             ("Docker",       "yes" if self.has_docker else "no"),
             ("Tests",        "yes" if self.include_tests else "no"),
             ("Dry-run",      "yes" if self.dry_run else "no"),

fastapi_spawn-0.3.0/fastapi_spawn/constants.py

@@ -0,0 +1,266 @@
+"""Constants and enums for fastapi-spawn — the complete FastAPI ecosystem."""
+
+from enum import Enum
+
+
+# ── Database ───────────────────────────────────────────────────────────────
+
+class Database(str, Enum):
+    postgresql = "postgresql"
+    mysql      = "mysql"
+    mongodb    = "mongodb"
+    sqlite     = "sqlite"
+    supabase   = "supabase"   # managed Postgres + realtime
+    duckdb     = "duckdb"     # analytical / OLAP queries
+    none       = "none"
+
+
+class ORM(str, Enum):
+    sqlalchemy = "sqlalchemy"
+    sqlmodel   = "sqlmodel"   # Pydantic v2 + SQLAlchemy — type-safe
+    tortoise   = "tortoise"
+    beanie     = "beanie"     # MongoDB ODM
+    none       = "none"
+
+
+class MigrationTool(str, Enum):
+    alembic = "alembic"
+    aerich  = "aerich"
+    none    = "none"
+
+
+# ── Auth ───────────────────────────────────────────────────────────────────
+
+class AuthType(str, Enum):
+    jwt      = "jwt"
+    oauth2   = "oauth2"
+    api_key  = "api-key"
+    auth0    = "auth0"    # managed identity (Auth0 / Okta)
+    none     = "none"
+
+
+# ── Messaging ──────────────────────────────────────────────────────────────
+
+class Broker(str, Enum):
+    redis    = "redis"    # Celery + Redis
+    rabbitmq = "rabbitmq" # Celery + RabbitMQ
+    kafka    = "kafka"    # aiokafka
+    arq      = "arq"      # lightweight async Redis task queue
+    none     = "none"
+
+
+class Cache(str, Enum):
+    redis     = "redis"
+    memcached = "memcached"
+    none      = "none"
+
+
+# ── Storage ────────────────────────────────────────────────────────────────
+
+class Storage(str, Enum):
+    s3         = "s3"         # AWS S3 or MinIO
+    gcs        = "gcs"        # Google Cloud Storage
+    cloudinary = "cloudinary" # image/video CDN
+    local      = "local"
+    none       = "none"
+
+
+# ── AI / LLM ──────────────────────────────────────────────────────────────
+
+class AIProvider(str, Enum):
+    openai     = "openai"
+    anthropic  = "anthropic"
+    gemini     = "gemini"
+    ollama     = "ollama"      # local, no API key
+    langchain  = "langchain"   # framework (wraps any LLM)
+    llamaindex = "llamaindex"  # RAG-focused framework
+    none       = "none"
+
+
+# ── Monitoring ─────────────────────────────────────────────────────────────
+
+class MonitoringProvider(str, Enum):
+    sentry        = "sentry"
+    prometheus    = "prometheus"
+    opentelemetry = "opentelemetry"  # vendor-neutral OTEL tracing
+    both          = "both"           # sentry + prometheus
+    none          = "none"
+
+
+# ── Email ─────────────────────────────────────────────────────────────────
+
+class EmailProvider(str, Enum):
+    sendgrid = "sendgrid"
+    smtp     = "smtp"
+    ses      = "ses"
+    none     = "none"
+
+
+# ── Notifications ──────────────────────────────────────────────────────────
+
+class NotificationProvider(str, Enum):
+    slack   = "slack"
+    discord = "discord"
+    none    = "none"
+
+
+# ── Logging ────────────────────────────────────────────────────────────────
+
+class LogLibrary(str, Enum):
+    loguru   = "loguru"
+    structlog = "structlog"
+    standard = "standard"
+
+
+class LogDestination(str, Enum):
+    local      = "local"
+    cloudwatch = "cloudwatch"  # AWS CloudWatch Logs
+    datadog    = "datadog"
+    none       = "none"
+
+
+# ── Vector database ────────────────────────────────────────────────────────
+
+class VectorDB(str, Enum):
+    qdrant        = "qdrant"
+    chroma        = "chroma"         # ChromaDB — local dev
+    pinecone      = "pinecone"
+    supabase      = "supabase"       # pgvector on Supabase
+    elasticsearch = "elasticsearch"
+    none          = "none"
+
+
+# ── Deployment ─────────────────────────────────────────────────────────────
+
+class Stack(str, Enum):
+    minimal  = "minimal"
+    standard = "standard"
+    full     = "full"
+
+
+class CIProvider(str, Enum):
+    github  = "github"
+    gitlab  = "gitlab"
+    both    = "both"
+    none    = "none"
+
+
+class APIExtra(str, Enum):
+    websockets = "websockets"  # WebSocket endpoint + connection manager
+    graphql    = "graphql"     # Strawberry GraphQL schema + router
+    both       = "both"        # WebSockets + GraphQL
+    none       = "none"
+
+
+# ── Compatibility matrices ─────────────────────────────────────────────────
+
+ORM_DB_COMPAT: dict[str, list[str]] = {
+    ORM.sqlalchemy: [Database.postgresql, Database.mysql, Database.sqlite, Database.supabase],
+    ORM.sqlmodel:   [Database.postgresql, Database.mysql, Database.sqlite, Database.supabase],
+    ORM.tortoise:   [Database.postgresql, Database.mysql, Database.sqlite],
+    ORM.beanie:     [Database.mongodb],
+    ORM.none:       list(Database),
+}
+
+MIGRATION_ORM_COMPAT: dict[str, list[str]] = {
+    MigrationTool.alembic: [ORM.sqlalchemy, ORM.sqlmodel],
+    MigrationTool.aerich:  [ORM.tortoise],
+    MigrationTool.none:    list(ORM),
+}
+
+# ── Human-readable labels ──────────────────────────────────────────────────
+
+DB_LABELS = {
+    Database.postgresql: "PostgreSQL — production SQL",
+    Database.mysql:      "MySQL / MariaDB",
+    Database.mongodb:    "MongoDB",
+    Database.sqlite:     "SQLite — local dev",
+    Database.supabase:   "Supabase — managed Postgres + realtime",
+    Database.duckdb:     "DuckDB — analytical / OLAP",
+    Database.none:       "No database",
+}
+
+ORM_LABELS = {
+    ORM.sqlalchemy: "SQLAlchemy 2.x async",
+    ORM.sqlmodel:   "SQLModel — Pydantic v2 + SQLAlchemy (type-safe)",
+    ORM.tortoise:   "Tortoise ORM",
+    ORM.beanie:     "Beanie — async MongoDB ODM",
+    ORM.none:       "No ORM",
+}
+
+AUTH_LABELS = {
+    AuthType.jwt:     "JWT (python-jose + passlib)",
+    AuthType.oauth2:  "OAuth2 Password flow",
+    AuthType.api_key: "API Key header",
+    AuthType.auth0:   "Auth0 / Okta — managed identity",
+    AuthType.none:    "No authentication",
+}
+
+BROKER_LABELS = {
+    Broker.redis:    "Redis — Celery broker + result backend",
+    Broker.rabbitmq: "RabbitMQ — Celery broker",
+    Broker.kafka:    "Kafka — aiokafka streams",
+    Broker.arq:      "Arq — lightweight async Redis task queue",
+    Broker.none:     "No message broker",
+}
+
+STORAGE_LABELS = {
+    Storage.s3:         "AWS S3 / MinIO (boto3)",
+    Storage.gcs:        "Google Cloud Storage",
+    Storage.cloudinary: "Cloudinary — image/video CDN",
+    Storage.local:      "Local filesystem",
+    Storage.none:       "No file storage",
+}
+
+AI_LABELS = {
+    AIProvider.openai:     "OpenAI — GPT-4o, embeddings (custom base URL supported)",
+    AIProvider.anthropic:  "Anthropic — Claude 3.x",
+    AIProvider.gemini:     "Google Gemini — multi-modal",
+    AIProvider.ollama:     "Ollama — local LLM, no API key",
+    AIProvider.langchain:  "LangChain — LLM orchestration framework",
+    AIProvider.llamaindex: "LlamaIndex — RAG / data-to-LLM framework",
+    AIProvider.none:       "No AI integration",
+}
+
+MONITORING_LABELS = {
+    MonitoringProvider.sentry:        "Sentry — error tracking + performance",
+    MonitoringProvider.prometheus:    "Prometheus — metrics via instrumentator",
+    MonitoringProvider.opentelemetry: "OpenTelemetry — vendor-neutral tracing",
+    MonitoringProvider.both:          "Sentry + Prometheus",
+    MonitoringProvider.none:          "No monitoring",
+}
+
+EMAIL_LABELS = {
+    EmailProvider.sendgrid: "SendGrid",
+    EmailProvider.smtp:     "SMTP (fastapi-mail)",
+    EmailProvider.ses:      "AWS SES",
+    EmailProvider.none:     "No email",
+}
+
+NOTIFICATION_LABELS = {
+    NotificationProvider.slack:   "Slack — incoming webhooks",
+    NotificationProvider.discord: "Discord — webhooks",
+    NotificationProvider.none:    "No notifications",
+}
+
+LOG_DEST_LABELS = {
+    LogDestination.local:      "Local — rotating file (daily, configurable retention)",
+    LogDestination.cloudwatch: "AWS CloudWatch Logs",
+    LogDestination.datadog:    "Datadog Logs",
+    LogDestination.none:       "Console only",
+}
+
+VECTOR_DB_LABELS = {
+    VectorDB.qdrant:        "Qdrant — local Docker or Qdrant Cloud",
+    VectorDB.chroma:        "ChromaDB — local open-source vector DB",
+    VectorDB.pinecone:      "Pinecone — managed cloud",
+    VectorDB.supabase:      "Supabase pgvector",
+    VectorDB.elasticsearch: "Elasticsearch — kNN search",
+    VectorDB.none:          "No vector database",
+}
+
+STACK_DESCRIPTIONS = {
+    Stack.minimal:  "Core app only — no Docker, no infra",
+    Stack.standard: "App + Docker + GitHub CI",
+    Stack.full:     "App + Docker + CI + Helm + Terraform",
+}

{fastapi_spawn-0.2.0 → fastapi_spawn-0.3.0}/fastapi_spawn/generator.py

@@ -176,6 +176,11 @@ class ProjectGenerator:
         self._render_to(v1 / "health.py", "app/api/v1/health.py.j2")
         if self.config.has_auth:
             self._render_to(v1 / "auth.py", "app/api/v1/auth.py.j2")
+        if self.config.has_websockets:
+            self._render_to(v1 / "ws.py", "app/api/v1/ws.py.j2")
+            self._render_to(core / "ws_manager.py", "app/core/ws_manager.py.j2")
+        if self.config.has_graphql:
+            self._render_to(api / "graphql.py", "app/api/graphql.py.j2")
 
         # db/ (only when a real database is chosen)
         if self.config.db.value != "none":

fastapi_spawn-0.3.0/fastapi_spawn/templates/app/api/graphql.py.j2

@@ -0,0 +1,98 @@
+"""Strawberry GraphQL schema and router for {{ project_name }}."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import strawberry
+from strawberry.fastapi import GraphQLRouter
+from strawberry.scalars import JSON
+
+
+# ── Types ──────────────────────────────────────────────────────────────────
+
+@strawberry.type
+class HealthType:
+    status: str
+    service: str
+    version: str
+
+
+@strawberry.type
+class MessageType:
+    id: str
+    content: str
+    author: str
+
+
+@strawberry.input
+class CreateMessageInput:
+    content: str
+    author: str
+
+
+# ── Query ──────────────────────────────────────────────────────────────────
+
+@strawberry.type
+class Query:
+    @strawberry.field(description="Health check for GraphQL layer")
+    def health(self) -> HealthType:
+        return HealthType(status="ok", service="{{ project_name }}", version="0.1.0")
+
+    @strawberry.field(description="List messages (stub — wire to DB)")
+    def messages(self, limit: int = 10) -> list[MessageType]:
+        # TODO: Replace with real DB query
+        return [
+            MessageType(id="1", content="Hello from GraphQL!", author="system"),
+        ]
+
+    @strawberry.field(description="Get a message by ID (stub)")
+    def message(self, id: str) -> Optional[MessageType]:
+        # TODO: Replace with real DB query
+        if id == "1":
+            return MessageType(id="1", content="Hello from GraphQL!", author="system")
+        return None
+
+
+# ── Mutation ───────────────────────────────────────────────────────────────
+
+@strawberry.type
+class Mutation:
+    @strawberry.mutation(description="Create a new message (stub — wire to DB)")
+    def create_message(self, input: CreateMessageInput) -> MessageType:
+        import uuid
+        # TODO: Replace with real DB insert
+        return MessageType(id=str(uuid.uuid4()), content=input.content, author=input.author)
+
+
+# ── Subscription ───────────────────────────────────────────────────────────
+
+import asyncio
+from typing import AsyncGenerator
+
+
+@strawberry.type
+class Subscription:
+    @strawberry.subscription(description="Subscribe to new messages (requires Redis pub/sub in production)")
+    async def message_added(self) -> AsyncGenerator[MessageType, None]:
+        """Stub subscription — fires a fake message every 3 seconds."""
+        import uuid
+        while True:
+            await asyncio.sleep(3)
+            yield MessageType(id=str(uuid.uuid4()), content="Live update!", author="system")
+
+
+# ── Schema & Router ────────────────────────────────────────────────────────
+
+schema = strawberry.Schema(
+    query=Query,
+    mutation=Mutation,
+    subscription=Subscription,
+)
+
+# Mount with: app.include_router(graphql_router, prefix="/graphql")
+graphql_router = GraphQLRouter(
+    schema,
+    graphiql=True,          # GraphiQL IDE at /graphql — disable in production
+    subscription_protocols=["graphql-transport-ws", "graphql-ws"],
+)

fastapi_spawn-0.3.0/fastapi_spawn/templates/app/api/v1/ws.py.j2

@@ -0,0 +1,67 @@
+"""WebSocket endpoints for {{ project_name }}."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, status
+from app.core.ws_manager import manager
+from app.core.logger import logger
+
+router = APIRouter(prefix="/ws")
+
+
+@router.websocket("/connect")
+async def ws_connect(websocket: WebSocket) -> None:
+    """
+    General-purpose WebSocket endpoint.
+    Connect: ws://host/api/v1/ws/connect
+
+    Protocol:
+      Client → Server:  {"type": "message", "data": "hello"}
+      Server → Client:  {"type": "ack", "client_id": "...", "data": "..."}
+    """
+    client_id = await manager.connect(websocket)
+    logger.info("WS connected: %s  total=%d", client_id, manager.connected_count)
+
+    try:
+        await manager.send_personal(
+            {"type": "connected", "client_id": client_id, "total": manager.connected_count},
+            client_id,
+        )
+        while True:
+            data = await websocket.receive_json()
+            msg_type = data.get("type", "message")
+
+            if msg_type == "broadcast":
+                # Relay to all clients
+                await manager.broadcast({"type": "broadcast", "from": client_id, "data": data.get("data")})
+            elif msg_type == "ping":
+                await manager.send_personal({"type": "pong"}, client_id)
+            else:
+                # Echo back with ack
+                await manager.send_personal(
+                    {"type": "ack", "client_id": client_id, "received": data}, client_id
+                )
+
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
+        logger.info("WS disconnected: %s  total=%d", client_id, manager.connected_count)
+        await manager.broadcast({"type": "user_left", "client_id": client_id})
+
+
+@router.websocket("/connect/{room_id}")
+async def ws_room(websocket: WebSocket, room_id: str) -> None:
+    """
+    Room-scoped WebSocket endpoint.
+    Connect: ws://host/api/v1/ws/connect/{room_id}
+    """
+    client_id = await manager.connect(websocket, client_id=f"{room_id}:{websocket.headers.get('sec-websocket-key', 'anon')[:8]}")
+    logger.info("WS room=%s client=%s", room_id, client_id)
+
+    try:
+        await manager.send_personal({"type": "joined", "room": room_id, "client_id": client_id}, client_id)
+        while True:
+            data = await websocket.receive_json()
+            await manager.broadcast({"type": "room_message", "room": room_id, "from": client_id, "data": data.get("data")})
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
+        await manager.broadcast({"type": "user_left", "room": room_id, "client_id": client_id})

fastapi_spawn-0.3.0/fastapi_spawn/templates/app/core/ai.py.j2

@@ -0,0 +1,143 @@
+"""AI / LLM client utilities for {{ project_name }}."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+from app.core.config import settings
+
+{% if ai == "openai" %}
+from openai import AsyncOpenAI
+
+
+@lru_cache
+def get_openai_client() -> AsyncOpenAI:
+    return AsyncOpenAI(
+        api_key=settings.OPENAI_API_KEY,
+        base_url=settings.OPENAI_BASE_URL or None,
+    )
+
+
+async def chat_completion(messages: list[dict], model: str | None = None, temperature: float = 0.7, max_tokens: int = 1024) -> str:
+    response = await get_openai_client().chat.completions.create(
+        model=model or settings.OPENAI_MODEL, messages=messages,
+        temperature=temperature, max_tokens=max_tokens,
+    )
+    return response.choices[0].message.content or ""
+
+
+async def get_embedding(text: str, model: str | None = None) -> list[float]:
+    response = await get_openai_client().embeddings.create(
+        model=model or settings.OPENAI_EMBEDDING_MODEL, input=text,
+    )
+    return response.data[0].embedding
+
+{% elif ai == "anthropic" %}
+import anthropic
+
+
+@lru_cache
+def get_anthropic_client() -> anthropic.AsyncAnthropic:
+    return anthropic.AsyncAnthropic(api_key=settings.ANTHROPIC_API_KEY)
+
+
+async def chat_completion(messages: list[dict], system: str = "You are a helpful assistant.", model: str | None = None, max_tokens: int = 1024) -> str:
+    response = await get_anthropic_client().messages.create(
+        model=model or settings.ANTHROPIC_MODEL, max_tokens=max_tokens,
+        system=system, messages=messages,
+    )
+    return response.content[0].text
+
+{% elif ai == "gemini" %}
+import google.generativeai as genai
+
+genai.configure(api_key=settings.GEMINI_API_KEY)
+
+
+async def chat_completion(prompt: str, model: str | None = None) -> str:
+    m = genai.GenerativeModel(model or settings.GEMINI_MODEL)
+    response = m.generate_content(prompt)
+    return response.text
+
+
+async def get_embedding(text: str) -> list[float]:
+    result = genai.embed_content(model="models/text-embedding-004", content=text)
+    return result["embedding"]
+
+{% elif ai == "ollama" %}
+import httpx
+
+
+async def chat_completion(messages: list[dict], model: str | None = None, temperature: float = 0.7) -> str:
+    async with httpx.AsyncClient(timeout=120) as client:
+        r = await client.post(
+            f"{settings.ollama_url}/api/chat",
+            json={"model": model or settings.OLLAMA_MODEL, "messages": messages,
+                  "stream": False, "options": {"temperature": temperature}},
+        )
+        r.raise_for_status()
+        return r.json()["message"]["content"]
+
+
+async def get_embedding(text: str, model: str = "nomic-embed-text") -> list[float]:
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.post(f"{settings.ollama_url}/api/embeddings", json={"model": model, "prompt": text})
+        r.raise_for_status()
+        return r.json()["embedding"]
+
+{% elif ai == "langchain" %}
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage
+
+
+@lru_cache
+def get_llm() -> ChatOpenAI:
+    """Return a cached LangChain ChatOpenAI instance."""
+    return ChatOpenAI(
+        api_key=settings.OPENAI_API_KEY,
+        model=settings.OPENAI_MODEL,
+        base_url=settings.OPENAI_BASE_URL or None,
+        temperature=0.7,
+    )
+
+
+async def chat_completion(user_message: str, system: str = "You are a helpful assistant.") -> str:
+    """Single-turn chat completion via LangChain."""
+    llm = get_llm()
+    messages = [SystemMessage(content=system), HumanMessage(content=user_message)]
+    response = await llm.ainvoke(messages)
+    return response.content
+
+
+async def get_embedding(text: str) -> list[float]:
+    """Generate an embedding using LangChain OpenAI embeddings."""
+    from langchain_openai import OpenAIEmbeddings
+    embeddings = OpenAIEmbeddings(api_key=settings.OPENAI_API_KEY, model=settings.OPENAI_EMBEDDING_MODEL)
+    return await embeddings.aembed_query(text)
+
+{% elif ai == "llamaindex" %}
+from llama_index.core import Settings as LlamaSettings
+from llama_index.llms.openai import OpenAI
+from llama_index.embeddings.openai import OpenAIEmbedding
+
+
+def configure_llama_index() -> None:
+    """Configure LlamaIndex global settings. Call once at startup."""
+    LlamaSettings.llm = OpenAI(
+        api_key=settings.OPENAI_API_KEY,
+        model=settings.OPENAI_MODEL,
+        api_base=settings.OPENAI_BASE_URL or None,
+    )
+    LlamaSettings.embed_model = OpenAIEmbedding(
+        api_key=settings.OPENAI_API_KEY,
+        model=settings.OPENAI_EMBEDDING_MODEL,
+    )
+
+
+async def query_index(index, question: str, similarity_top_k: int = 5) -> str:
+    """Query a LlamaIndex VectorStoreIndex."""
+    query_engine = index.as_query_engine(similarity_top_k=similarity_top_k)
+    response = await query_engine.aquery(question)
+    return str(response)
+
+{% endif %}