appgenerator-cli 1.0.0__py3-none-any.whl

pyforge/templates/ai/.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# uv
+.uv/
+
+# Environment
+.env
+!.env.example
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Type checking
+.mypy_cache/
+
+# Vector DB / embeddings
+chroma_db/
+*.faiss
+*.pkl
+
+# LangSmith / LangChain cache
+.langchain.db
+langchain_cache/
+
+# Logs
+*.log
+logs/

pyforge/templates/ai/Dockerfile

@@ -0,0 +1,22 @@
+# ── Build stage ────────────────────────────────────────────────────────────────
+FROM python:3.12-slim AS builder
+
+WORKDIR /app
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+COPY pyproject.toml uv.lock* ./
+RUN uv sync --frozen --no-dev
+
+# ── Runtime stage ──────────────────────────────────────────────────────────────
+FROM python:3.12-slim AS runtime
+
+WORKDIR /app
+
+COPY --from=builder /app/.venv /app/.venv
+ENV PATH="/app/.venv/bin:$PATH"
+
+COPY app ./app
+COPY main.py ./main.py
+
+CMD ["python", "main.py"]

pyforge/templates/ai/README.md

@@ -0,0 +1,97 @@
+# {{ project_name }}
+
+A production-ready LangChain / LangGraph AI application, scaffolded by [AppGenerator](https://github.com/yourname/appgenerator-cli).
+
+## Tech Stack
+
+- **[LangChain](https://python.langchain.com/)** — LLM orchestration framework
+- **[LangGraph](https://langchain-ai.github.io/langgraph/)** — stateful agent graphs
+- **[LangChain-OpenAI](https://python.langchain.com/docs/integrations/chat/openai)** — OpenAI chat models
+- **[LangChain-Ollama](https://python.langchain.com/docs/integrations/chat/ollama)** — local Ollama models
+- **[ChromaDB](https://docs.trychroma.com/)** — local vector store for RAG
+- **[Pydantic Settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/)** — typed config from env
+- **[uv](https://docs.astral.sh/uv/)** — blazing-fast package management
+{% if postgres %}- **pgvector** — PostgreSQL vector extension
+{% endif %}{% if redis %}- **Redis** — semantic caching layer
+{% endif %}{% if docker %}- **Docker** — containerisation
+{% endif %}
+
+## Project Structure
+
+```
+{{ project_name }}/
+├── main.py                  # Interactive REPL entry point
+├── app/
+│   ├── config.py            # Typed settings (pydantic-settings)
+│   ├── agents/
+│   │   ├── __init__.py
+│   │   └── assistant.py     # LangGraph ReAct agent
+│   ├── chains/
+│   │   ├── __init__.py
+│   │   └── rag.py           # RAG chain example
+│   ├── tools/
+│   │   ├── __init__.py
+│   │   ├── registry.py      # Tool registry (add tools here)
+│   │   └── search.py        # Web search tool stub
+├── tests/
+│   ├── conftest.py
+│   ├── test_agent.py
+│   └── __init__.py
+├── .env.example
+├── .gitignore
+└── pyproject.toml
+```
+
+## Getting Started
+
+```bash
+# 1. Copy and configure your secrets
+cp .env.example .env
+# Edit .env — add your OPENAI_API_KEY
+
+# 2. Run the interactive assistant
+uv run python main.py
+```
+
+## Using Ollama (Local Models)
+
+```bash
+# Install Ollama: https://ollama.com
+ollama pull llama3.2
+
+# Update .env
+OLLAMA_MODEL=llama3.2
+```
+
+Then swap the LLM in `app/agents/assistant.py`:
+
+```python
+from langchain_ollama import ChatOllama
+self._llm = ChatOllama(model=settings.ollama_model, base_url=settings.ollama_base_url)
+```
+
+## Adding Tools
+
+Edit `app/tools/registry.py` and add your tools to `get_tools()`:
+
+```python
+from app.tools.my_tool import my_custom_tool
+
+def get_tools():
+    return [web_search_tool, my_custom_tool]
+```
+
+## Running Tests
+
+```bash
+uv run pytest
+```
+
+## LangSmith Tracing (optional)
+
+```bash
+# .env
+LANGCHAIN_TRACING_V2=true
+LANGCHAIN_API_KEY=ls__your_key
+LANGCHAIN_PROJECT={{ project_name }}
+```

pyforge/templates/ai/app/__init__.py

@@ -0,0 +1 @@
+"""{{ project_name }} AI application package."""

pyforge/templates/ai/app/agents/__init__.py

@@ -0,0 +1 @@
+"""Agent definitions."""

pyforge/templates/ai/app/agents/assistant.py

@@ -0,0 +1,100 @@
+"""
+AssistantAgent — a simple LangGraph ReAct agent wired to the configured LLM.
+
+Extend this class to add memory, tools, and custom graph nodes.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from langgraph.graph import END, START, MessagesState, StateGraph
+
+from app.config import settings
+from app.tools.registry import get_tools
+
+
+class AssistantAgent:
+    """A LangGraph-powered conversational agent."""
+
+    SYSTEM_PROMPT = (
+        "You are a helpful, concise, and accurate assistant. "
+        "Use the available tools when appropriate. "
+        "If you don't know something, say so honestly."
+    )
+
+    def __init__(self) -> None:
+        self._llm = ChatOpenAI(
+            model=settings.openai_model,
+            api_key=settings.openai_api_key,
+            temperature=0.2,
+        )
+        self._tools = get_tools()
+        self._llm_with_tools = self._llm.bind_tools(self._tools)
+        self._graph = self._build_graph()
+
+    # ------------------------------------------------------------------ #
+    #  Public
+    # ------------------------------------------------------------------ #
+
+    async def invoke(self, user_message: str, history: list[dict[str, str]] | None = None) -> str:
+        """Run the agent and return the assistant's reply."""
+        messages = [SystemMessage(content=self.SYSTEM_PROMPT)]
+
+        for msg in (history or []):
+            if msg["role"] == "user":
+                messages.append(HumanMessage(content=msg["content"]))
+            # assistant messages are added by LangGraph internally
+
+        messages.append(HumanMessage(content=user_message))
+
+        result = await self._graph.ainvoke({"messages": messages})
+        return result["messages"][-1].content  # type: ignore[index]
+
+    # ------------------------------------------------------------------ #
+    #  Graph construction
+    # ------------------------------------------------------------------ #
+
+    def _build_graph(self) -> Any:
+        """Build a minimal ReAct graph: call model → maybe call tools → end."""
+        builder = StateGraph(MessagesState)
+
+        builder.add_node("agent", self._call_model)
+        builder.add_node("tools", self._call_tools)
+
+        builder.add_edge(START, "agent")
+        builder.add_conditional_edges("agent", self._should_use_tools)
+        builder.add_edge("tools", "agent")
+
+        return builder.compile()
+
+    async def _call_model(self, state: MessagesState) -> dict[str, Any]:
+        response = await self._llm_with_tools.ainvoke(state["messages"])
+        return {"messages": [response]}
+
+    async def _call_tools(self, state: MessagesState) -> dict[str, Any]:
+        from langchain_core.messages import ToolMessage
+
+        last_message = state["messages"][-1]
+        tool_map = {t.name: t for t in self._tools}
+        results = []
+
+        for tool_call in last_message.tool_calls:  # type: ignore[attr-defined]
+            tool = tool_map.get(tool_call["name"])
+            if tool is None:
+                output = f"Error: unknown tool '{tool_call['name']}'"
+            else:
+                output = await tool.ainvoke(tool_call["args"])
+            results.append(
+                ToolMessage(content=str(output), tool_call_id=tool_call["id"])
+            )
+
+        return {"messages": results}
+
+    @staticmethod
+    def _should_use_tools(state: MessagesState) -> str:
+        last = state["messages"][-1]
+        if hasattr(last, "tool_calls") and last.tool_calls:  # type: ignore[attr-defined]
+            return "tools"
+        return END

pyforge/templates/ai/app/chains/__init__.py

@@ -0,0 +1 @@
+"""Reusable LangChain chain definitions."""

pyforge/templates/ai/app/chains/rag.py

@@ -0,0 +1,50 @@
+"""
+Retrieval-Augmented Generation (RAG) chain.
+
+Usage:
+    from app.chains.rag import build_rag_chain
+    chain = build_rag_chain(vectorstore)
+    answer = await chain.ainvoke({"question": "What is LangGraph?"})
+"""
+from __future__ import annotations
+
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.vectorstores import VectorStore
+from langchain_openai import ChatOpenAI
+
+from app.config import settings
+
+RAG_PROMPT = ChatPromptTemplate.from_template(
+    """You are a helpful assistant. Answer the question using ONLY the provided context.
+If the answer is not in the context, say "I don't know".
+
+Context:
+{context}
+
+Question: {question}
+
+Answer:"""
+)
+
+
+def build_rag_chain(vectorstore: VectorStore):
+    """Build a RAG chain from a pre-loaded vector store."""
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
+    llm = ChatOpenAI(
+        model=settings.openai_model,
+        api_key=settings.openai_api_key,
+        temperature=0,
+    )
+
+    def format_docs(docs: list) -> str:
+        return "\n\n".join(doc.page_content for doc in docs)
+
+    chain = (
+        {"context": retriever | format_docs, "question": RunnablePassthrough()}
+        | RAG_PROMPT
+        | llm
+        | StrOutputParser()
+    )
+    return chain

pyforge/templates/ai/app/config.py

@@ -0,0 +1,47 @@
+"""
+Typed settings for the AI application, loaded from .env.
+"""
+from functools import lru_cache
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    # App
+    app_name: str = "{{ project_name }}"
+    app_env: str = "development"
+    debug: bool = True
+
+    # LLM — OpenAI
+    openai_api_key: str = ""
+    openai_model: str = "gpt-4o-mini"
+
+    # LLM — Ollama (local)
+    ollama_base_url: str = "http://localhost:11434"
+    ollama_model: str = "llama3.2"
+
+    # Vector store
+    chroma_persist_dir: str = "./chroma_db"
+{% if postgres %}
+    # pgvector
+    pgvector_url: str = ""
+{% endif %}
+{% if redis %}
+    # Redis
+    redis_url: str = "redis://localhost:6379/0"
+{% endif %}
+
+    # LangSmith tracing (set via env vars)
+    langchain_tracing_v2: bool = False
+    langchain_api_key: str = ""
+    langchain_project: str = "{{ project_name }}"
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+
+
+settings = get_settings()

pyforge/templates/ai/app/tools/__init__.py

@@ -0,0 +1 @@
+"""Custom LangChain tools."""

pyforge/templates/ai/app/tools/registry.py

@@ -0,0 +1,19 @@
+"""
+Tool registry — add your custom tools here and they are automatically
+bound to the AssistantAgent.
+"""
+from __future__ import annotations
+
+from langchain_core.tools import BaseTool
+
+from app.tools.search import web_search_tool
+
+
+def get_tools() -> list[BaseTool]:
+    """Return all tools available to the agent."""
+    return [
+        web_search_tool,
+        # Add more tools here, e.g.:
+        # calculator_tool,
+        # retriever_tool,
+    ]

pyforge/templates/ai/app/tools/search.py

@@ -0,0 +1,34 @@
+"""
+Example tool: simple web search stub.
+
+Replace the implementation with a real provider such as:
+- Tavily:  `pip install langchain-tavily`
+- SerpAPI: `pip install google-search-results`
+- DuckDuckGo: `pip install duckduckgo-search`
+"""
+from langchain_core.tools import tool
+
+
+@tool
+async def web_search_tool(query: str) -> str:
+    """Search the web for up-to-date information on a given query.
+
+    Args:
+        query: The search query string.
+
+    Returns:
+        A string summarising the top search results.
+    """
+    # ── Stub — replace with a real search provider ──────────────────────
+    # Example using Tavily (recommended for LangChain agents):
+    #
+    #   from langchain_community.tools.tavily_search import TavilySearchResults
+    #   search = TavilySearchResults(max_results=3)
+    #   results = await search.ainvoke({"query": query})
+    #   return "\n".join(r["content"] for r in results)
+    #
+    # ────────────────────────────────────────────────────────────────────
+    return (
+        f"[web_search stub] No live results for '{query}'. "
+        "Configure a real search provider in app/tools/search.py."
+    )

pyforge/templates/ai/docker-compose.yml

@@ -0,0 +1,39 @@
+version: "3.9"
+
+services:
+  app:
+    build: .
+    env_file: .env
+    volumes:
+      - ./chroma_db:/app/chroma_db
+    {% if redis or postgres %}depends_on:{% endif %}
+      {% if postgres %}- postgres{% endif %}
+      {% if redis %}- redis{% endif %}
+    restart: unless-stopped
+
+  {% if postgres %}
+  postgres:
+    image: pgvector/pgvector:pg16
+    environment:
+      POSTGRES_DB: {{ package_name }}_vectors
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    ports:
+      - "5432:5432"
+    volumes:
+      - pg_data:/var/lib/postgresql/data
+    restart: unless-stopped
+  {% endif %}
+
+  {% if redis %}
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    restart: unless-stopped
+  {% endif %}
+
+{% if postgres %}
+volumes:
+  pg_data:
+{% endif %}

pyforge/templates/ai/main.py

@@ -0,0 +1,40 @@
+"""
+{{ project_name }} — LangChain / LangGraph application entry point.
+
+Run:
+    uv run python main.py
+"""
+import asyncio
+
+from app.agents.assistant import AssistantAgent
+from app.config import settings
+
+
+async def main() -> None:
+    print(f"🤖  {settings.app_name} starting up …\n")
+
+    agent = AssistantAgent()
+
+    # Interactive REPL
+    print("Type your message (Ctrl-C to quit):\n")
+    history: list[dict[str, str]] = []
+
+    while True:
+        try:
+            user_input = input("You: ").strip()
+        except (KeyboardInterrupt, EOFError):
+            print("\nGoodbye!")
+            break
+
+        if not user_input:
+            continue
+
+        response = await agent.invoke(user_input, history=history)
+        print(f"AI:  {response}\n")
+
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": response})
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

pyforge/templates/ai/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["uv_build>=0.11.2,<0.12"]
+build-backend = "uv_build"
+
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "A LangChain / LangGraph AI application"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.uv.build-backend]
+module-name = "app"
+module-root = ""
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = ["E", "F", "I", "N", "UP"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

pyforge/templates/ai/tests/__init__.py

@@ -0,0 +1 @@
+"""Test suite for {{ project_name }}."""

pyforge/templates/ai/tests/conftest.py

@@ -0,0 +1,21 @@
+"""Shared test fixtures for the AI application."""
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+
+@pytest.fixture
+def mock_openai():
+    """Patch ChatOpenAI so tests never hit the real API."""
+    with patch("langchain_openai.ChatOpenAI") as mock_cls:
+        instance = mock_cls.return_value
+        instance.ainvoke = AsyncMock(return_value=_fake_message("Test response"))
+        instance.bind_tools = lambda tools: instance
+        yield instance
+
+
+def _fake_message(content: str):
+    from langchain_core.messages import AIMessage
+    msg = AIMessage(content=content)
+    msg.tool_calls = []
+    return msg

pyforge/templates/ai/tests/test_agent.py

@@ -0,0 +1,53 @@
+"""Tests for the AssistantAgent."""
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from langchain_core.messages import AIMessage
+
+
+@pytest.mark.asyncio
+async def test_agent_returns_string_response():
+    """Agent.invoke() should return a plain string."""
+    fake_ai_msg = AIMessage(content="Hello, I am your assistant!")
+    fake_ai_msg.tool_calls = []  # no tool calls → goes straight to END
+
+    with (
+        patch("langchain_openai.ChatOpenAI") as mock_llm_cls,
+        patch("app.tools.registry.get_tools", return_value=[]),
+    ):
+        mock_llm = MagicMock()
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.ainvoke = AsyncMock(return_value=fake_ai_msg)
+        mock_llm_cls.return_value = mock_llm
+
+        from app.agents.assistant import AssistantAgent
+
+        agent = AssistantAgent()
+        result = await agent.invoke("Hello")
+
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+@pytest.mark.asyncio
+async def test_agent_passes_history():
+    """Agent should include prior history in the prompt."""
+    fake_ai_msg = AIMessage(content="I remember!")
+    fake_ai_msg.tool_calls = []
+
+    with (
+        patch("langchain_openai.ChatOpenAI") as mock_llm_cls,
+        patch("app.tools.registry.get_tools", return_value=[]),
+    ):
+        mock_llm = MagicMock()
+        mock_llm.bind_tools.return_value = mock_llm
+        mock_llm.ainvoke = AsyncMock(return_value=fake_ai_msg)
+        mock_llm_cls.return_value = mock_llm
+
+        from app.agents.assistant import AssistantAgent
+
+        agent = AssistantAgent()
+        history = [{"role": "user", "content": "My name is Alice"}]
+        result = await agent.invoke("What is my name?", history=history)
+
+    assert isinstance(result, str)

pyforge/templates/fastapi/.env.example

@@ -0,0 +1,17 @@
+# ── Application ──────────────────────────────────────────────
+APP_NAME="{{ project_name }}"
+APP_ENV=development          # development | staging | production
+DEBUG=true
+SECRET_KEY=change-me-to-a-random-secret
+
+# ── Server ────────────────────────────────────────────────────
+HOST=0.0.0.0
+PORT=8000
+
+# ── Database ──────────────────────────────────────────────────
+{% if postgres %}DATABASE_URL=postgresql+asyncpg://postgres:postgres@localhost:5432/{{ package_name }}_db
+{% else %}DATABASE_URL=sqlite+aiosqlite:///./{{ package_name }}.db
+{% endif %}
+{% if redis %}# ── Redis ────────────────────────────────────────────────────
+REDIS_URL=redis://localhost:6379/0
+{% endif %}

pyforge/templates/fastapi/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# uv
+.uv/
+
+# Environment
+.env
+!.env.example
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Type checking
+.mypy_cache/
+
+# DB
+*.db
+*.sqlite3
+
+# Logs
+*.log
+logs/