create-rag-app 0.1.2 → 0.2.1-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kundan Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,8 @@
-# Create RAG App
+# Create RAG App (Beta)
 
-Scaffold a production-ready RAG (Retrieval Augmented Generation) application in seconds.
+> **Note:** This project is currently in beta. Features and APIs are subject to change.
+
+Scaffold a RAG (Retrieval Augmented Generation) application in seconds.
 
 [![npm version](https://img.shields.io/npm/v/create-rag-app.svg)](https://www.npmjs.com/package/create-rag-app)
 [![npm downloads](https://img.shields.io/npm/dt/create-rag-app.svg)](https://www.npmjs.com/package/create-rag-app)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-rag-app",
-  "version": "0.1.2",
+  "version": "0.2.1-beta.1",
   "description": "Scaffold a new RAG application",
   "type": "module",
   "bin": {
@@ -34,10 +34,10 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@inquirer/prompts": "^8.3.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "fs-extra": "^11.3.3",
-    "inquirer": "^13.2.2",
     "ora": "^9.3.0"
   }
 }

package/src/index.js

@@ -3,7 +3,7 @@ import fs from "fs-extra";
 import chalk from "chalk";
 import { Command } from "commander";
 import { getOptions } from "./prompts.js";
-import { checkDir, copyTemplate, installDependencies } from "./utils.js";
+import { checkDir, copyTemplate, installDependencies, initGit } from "./utils.js";
 
 const packageJson = JSON.parse(
     await fs.readFile(new URL("../package.json", import.meta.url))
@@ -18,12 +18,18 @@ export async function main() {
         .version(packageJson.version)
         .arguments('[project-directory]')
         .usage(`${chalk.green('[project-directory]')} [options]`)
+        .option('-t, --template <template>', 'Specify the template (nextjs-rag, express-rag, fastapi-rag)')
+        .option('-p, --provider <provider>', 'Specify the LLM provider (openai, ollama, gemini)')
+        .option('-v, --vector-db <vectorDb>', 'Specify the Vector Database (chroma, pinecone, weaviate)')
+        .option('--skip-install', 'Skip dependency installation')
+        .option('--no-git', 'Skip git initialization')
         .action((name) => {
             projectName = name;
         })
         .parse(process.argv);
 
-    const options = await getOptions(projectName);
+    const cliOptions = program.opts();
+    const options = await getOptions(projectName, cliOptions);
     const projectPath = path.resolve(process.cwd(), options.projectName);
 
     console.log(`\nCreating a new RAG app in: ${chalk.green(projectPath)}\n`);
@@ -53,11 +59,58 @@ export async function main() {
         await fs.writeFile(envPath, envContent);
     }
 
+    // Update package.json based on selections
+    const pkgPath = path.join(projectPath, "package.json");
+    if (await fs.pathExists(pkgPath)) {
+        const pkg = await fs.readJson(pkgPath);
+
+        // Inject Pinecone dependencies if selected
+        if (options.vectorDb === "pinecone") {
+            pkg.dependencies = {
+                ...pkg.dependencies,
+                "@pinecone-database/pinecone": "^4.1.0",
+                "@langchain/pinecone": "^0.1.3"
+            };
+        }
+
+        // Inject Weaviate dependencies if selected
+        if (options.vectorDb === "weaviate") {
+            pkg.dependencies = {
+                ...pkg.dependencies,
+                "weaviate-ts-client": "^2.2.0",
+                "@langchain/weaviate": "^0.0.3"
+            };
+        }
+
+        // Inject Gemini dependencies if selected
+        if (options.provider === "gemini") {
+            pkg.dependencies["@langchain/google-genai"] = "^0.1.3";
+        }
+
+        await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    }
+
     // Install Dependencies (user requested automatic installation)
-    await installDependencies(projectPath);
+    let installed = false;
+    if (!options.skipInstall) {
+        installed = await installDependencies(projectPath);
+    } else {
+        console.log(chalk.yellow("\n⚠ Skipping dependency installation."));
+    }
+
+    // Initialize Git
+    if (options.git) {
+        await initGit(projectPath);
+    }
 
     // Final Success Message
-    console.log(chalk.bold.green("\n🎉 Success! Your RAG app is ready."));
+    if (installed) {
+        console.log(chalk.bold.green("\n🎉 Success! Your RAG app is ready."));
+    } else if (options.skipInstall) {
+        console.log(chalk.bold.green("\n🎉 Project created successfully."));
+    } else {
+        console.log(chalk.bold.yellow("\n⚠️  Project created, but dependencies failed to install."));
+    }
     console.log(chalk.yellow("\nNext steps:"));
     console.log(chalk.cyan(`  cd ${options.projectName}`));
     console.log(chalk.cyan(`  npm run dev`));

package/src/prompts.js

@@ -1,66 +1,71 @@
 
-import inquirer from "inquirer";
+import { input, select } from "@inquirer/prompts";
 
-export async function getOptions(initialProjectName) {
-    let questions = [
-        {
-            type: "input",
-            name: "projectName",
+export async function getOptions(initialProjectName, cliOptions = {}) {
+    let projectName = initialProjectName;
+
+    if (projectName) {
+        if (!/^([a-z0-9\-\_\.]+)$/.test(projectName)) {
+            console.log("⚠ Invalid project name provided via CLI.");
+            projectName = null; // Force prompt
+        }
+    }
+
+    if (!projectName) {
+        projectName = await input({
             message: "What is your project named?",
             default: "my-rag-app",
-            validate: (input) => {
-                if (/^([a-z0-9\-\_\.]+)$/.test(input)) return true;
+            validate: (value) => {
+                if (/^([a-z0-9\-\_\.]+)$/.test(value)) return true;
                 return "Project name may only include letters, numbers, dashes, and underscores.";
             },
-        },
-        {
-            type: "list",
-            name: "template",
-            message: "Which template would you like to use?",
+        });
+    }
+
+    let template = cliOptions.template;
+    if (!template) {
+        template = await select({
+            message: "Choose template",
             choices: [
-                { name: "Next.js + LangChain + ChromaDB (Recommended)", value: "nextjs-rag" },
-                { name: "Express API + PDF Processor (Backend Only)", value: "express-rag" }, // Future scope
+                { name: "Next.js", value: "nextjs-rag" },
+                { name: "Express", value: "express-rag" },
+                { name: "FastAPI", value: "fastapi-rag" },
             ],
             default: "nextjs-rag",
-        },
-        {
-            type: "list",
-            name: "provider",
-            message: "Which LLM provider do you want configured?",
+        });
+    }
+
+    let provider = cliOptions.provider;
+    if (!provider) {
+        provider = await select({
+            message: "Choose LLM",
             choices: [
-                { name: "OpenAI (GPT-4o, GPT-3.5)", value: "openai" },
-                { name: "Groq (Llama 3, Mixtral - Fast!)", value: "groq" },
-                { name: "Ollama (Local Models)", value: "ollama" },
-                { name: "Gemini (Google DeepMind)", value: "gemini" },
+                { name: "OpenAI", value: "openai" },
+                { name: "Gemini", value: "gemini" },
+                { name: "Ollama", value: "ollama" },
             ],
             default: "openai",
-        },
-        {
-            type: "list",
-            name: "vectorDb",
-            message: "Which Vector Database do you want to use?",
+        });
+    }
+
+    let vectorDb = cliOptions.vectorDb;
+    if (!vectorDb) {
+        vectorDb = await select({
+            message: "Choose Vector DB",
             choices: [
-                { name: "ChromaDB (Local)", value: "chroma" },
-                { name: "Supabase pgvector (Cloud)", value: "supabase" },
+                { name: "Chroma", value: "chroma" },
+                { name: "Pinecone", value: "pinecone" },
+                { name: "Weaviate", value: "weaviate" },
             ],
             default: "chroma",
-        },
-    ];
-
-    if (initialProjectName) {
-        if (/^([a-z0-9\-\_\.]+)$/.test(initialProjectName)) {
-            // Valid project name provided via CLI, skip the prompt
-            questions = questions.filter(q => q.name !== "projectName");
-        } else {
-            console.log("⚠ Invalid project name provided via CLI.");
-            initialProjectName = null; // Force prompt
-        }
+        });
     }
 
-    const answers = await inquirer.prompt(questions);
-
     return {
-        projectName: initialProjectName || answers.projectName,
-        ...answers
+        projectName,
+        template,
+        provider,
+        vectorDb,
+        ...cliOptions
     };
 }

package/src/utils.js

@@ -46,17 +46,31 @@ export async function installDependencies(targetPath) {
         // Run npm install in the new directory
         await execAsync("npm install", { cwd: targetPath });
         spinner.succeed(chalk.green("Dependencies installed via npm."));
+        return true;
     } catch (err) {
         // Fallback for peer dependency conflicts common in AI libraries
         try {
             spinner.text = "Retrying with --legacy-peer-deps...";
             await execAsync("npm install --legacy-peer-deps", { cwd: targetPath });
             spinner.succeed(chalk.green("Dependencies installed with legacy peer deps."));
+            return true;
         } catch (retryErr) {
             spinner.fail(chalk.red("Failed to install dependencies."));
+            if (retryErr.stderr) console.error(chalk.red(retryErr.stderr));
             console.log(chalk.yellow("You can try installing manually:"));
             console.log(chalk.cyan(`  cd ${path.basename(targetPath)}`));
             console.log(chalk.cyan("  npm install --legacy-peer-deps"));
+            return false;
         }
     }
 }
+
+export async function initGit(targetPath) {
+    const spinner = ora("Initializing git repository...").start();
+    try {
+        await execAsync("git init", { cwd: targetPath });
+        spinner.succeed(chalk.green("Git repository initialized."));
+    } catch (err) {
+        spinner.warn(chalk.yellow("Failed to initialize git repository."));
+    }
+}

package/templates/nextjs-rag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-rag-app",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "scripts": {
     "dev": "next dev",
@@ -10,24 +10,24 @@
     "ingest": "node scripts/ingest.js"
   },
   "dependencies": {
-    "next": "15.5.10",
-    "react": "19.0.0-rc-66855b96-20241106",
-    "react-dom": "19.0.0-rc-66855b96-20241106",
-    "langchain": "^0.3.5",
-    "@langchain/openai": "^0.3.11",
-    "@langchain/ollama": "^0.1.2",
-    "@langchain/google-genai": "^0.1.3",
     "@langchain/community": "^0.3.11",
     "@langchain/core": "^0.3.15",
+    "@langchain/google-genai": "^0.1.3",
+    "@langchain/ollama": "^0.1.2",
+    "@langchain/openai": "^0.3.11",
     "@langchain/textsplitters": "^0.1.0",
     "chromadb": "^1.9.4",
-    "pdf-parse": "1.1.1",
+    "dotenv": "^16.4.5",
+    "langchain": "^0.3.5",
+    "next": "^16.1.6",
     "openai": "^4.71.1",
-    "dotenv": "^16.4.5"
+    "pdf-parse": "1.1.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
   },
   "devDependencies": {
+    "autoprefixer": "^10.4.20",
     "postcss": "^8.4.47",
-    "tailwindcss": "^3.4.14",
-    "autoprefixer": "^10.4.20"
+    "tailwindcss": "^3.4.14"
   }
 }

package/templates/nextjs-rag/src/app/api/chat/route.js

@@ -1,6 +1,7 @@
 import { getLLM, getEmbeddings } from "@/lib/llm";
-import { Chroma } from "@langchain/community/vectorstores/chroma";
 import { PromptTemplate } from "@langchain/core/prompts";
+import { StringOutputParser } from "@langchain/core/output_parsers";
+import { RunnableSequence, RunnablePassthrough } from "@langchain/core/runnables";
 
 export async function POST(req) {
     try {
@@ -14,36 +15,65 @@ export async function POST(req) {
             );
         }
 
-        const vectorStore = await Chroma.fromExistingCollection(getEmbeddings(), {
-            collectionName: process.env.COLLECTION_NAME || "rag-docs",
-            url: process.env.CHROMA_URL || "http://localhost:8000"
-        });
+        let vectorStore;
+        const embeddings = getEmbeddings();
 
-        const retriever = vectorStore.asRetriever();
-        const llm = getLLM();
+        if (process.env.VECTOR_DB === "supabase") {
+            const { SupabaseVectorStore } = await import("@langchain/community/vectorstores/supabase");
+            const { createClient } = await import("@supabase/supabase-js");
+            const client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PRIVATE_KEY);
 
-        // 🔥 manually retrieve documents
-        const docs = await retriever.invoke(message);
+            vectorStore = await SupabaseVectorStore.fromExistingIndex(embeddings, {
+                client,
+                tableName: "documents",
+                queryName: "match_documents",
+            });
+        } else {
+            const { Chroma } = await import("@langchain/community/vectorstores/chroma");
+            vectorStore = await Chroma.fromExistingCollection(embeddings, {
+                collectionName: process.env.COLLECTION_NAME || "rag-docs",
+                url: process.env.CHROMA_URL || "http://localhost:8000"
+            });
+        }
 
-        const context = docs.map((doc) => doc.pageContent).join("\n\n");
+        const retriever = vectorStore.asRetriever();
+        const llm = getLLM();
 
-        const prompt = PromptTemplate.fromTemplate(`
+        const template = `
 Answer the question based only on the following context:
 
 {context}
 
 Question: {question}
-`);
+`;
 
-        const formattedPrompt = await prompt.format({
-            context,
-            question: message
-        });
+        const prompt = PromptTemplate.fromTemplate(template);
+
+        // Create an LCEL chain: Retriever -> Prompt -> LLM -> OutputParser
+        const chain = RunnableSequence.from([
+            {
+                context: retriever.pipe((docs) => docs.map((d) => d.pageContent).join("\n\n")),
+                question: new RunnablePassthrough()
+            },
+            prompt,
+            llm,
+            new StringOutputParser()
+        ]);
 
-        const result = await llm.invoke(formattedPrompt);
+        const stream = await chain.stream(message);
+
+        const textEncoder = new TextEncoder();
+        const readable = new ReadableStream({
+            async start(controller) {
+                for await (const chunk of stream) {
+                    controller.enqueue(textEncoder.encode(chunk));
+                }
+                controller.close();
+            }
+        });
 
-        return Response.json({
-            response: result.content
+        return new Response(readable, {
+            headers: { "Content-Type": "text/plain" },
         });
     } catch (error) {
         console.error(error);