Upload 35 files

FastMCPToolGenerator/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

FastMCPToolGenerator/.gitignore

@@ -0,0 +1,63 @@
+
+# Logs
+
+logs
+
+*.log
+
+npm-debug.log*
+
+yarn-debug.log*
+
+yarn-error.log*
+
+pnpm-debug.log*
+
+lerna-debug.log*
+
+
+
+node_modules
+
+dist
+
+dist-ssr
+
+*.local
+
+.env
+
+
+
+# Editor directories and files
+
+.vscode/*
+
+!.vscode/extensions.json
+
+.idea
+
+.DS_Store
+
+*.suo
+
+*.ntvs*
+
+*.njsproj
+
+*.sln
+
+*.sw?
+
+
+
+# Python
+
+__pycache__/
+
+*.pyc
+
+.venv
+
+venv/
+

FastMCPToolGenerator/App.tsx

@@ -0,0 +1,283 @@
+
+import React, { useState, useMemo } from 'react';
+
+import { ToolDefinition, GeneratedCode, ToolType, FunctionDefinition, ParameterType } from './types';
+
+import ToolForm from './components/ToolForm';
+
+import CodeOutput from './components/CodeOutput';
+
+import { generateAllCode } from './services/codeGenerator';
+
+import { nmapScannerExample } from './examples';
+
+import Button from './components/ui/Button';
+
+import AiPrompt from './components/AiPrompt';
+
+import { generateToolDefinitionFromPrompt } from './services/aiService';
+
+
+
+const initialFunction: FunctionDefinition = {
+
+  id: crypto.randomUUID(),
+
+  name: 'example_function',
+
+  description: 'Краткое описание того, что делает эта функция.',
+
+  parameters: [
+
+    {
+
+      id: crypto.randomUUID(),
+
+      name: 'example_param',
+
+      type: ParameterType.STRING, // Исправлено с 'str' as any
+
+      description: 'Описание параметра.',
+
+      required: true,
+
+    },
+
+  ],
+
+  returnType: ParameterType.STRING, // Исправлено с 'str' as any
+
+  returnDescription: 'Описание возвращаемого значения.',
+
+};
+
+
+
+const initialToolDefinition: ToolDefinition = {
+
+  name: 'my_tool',
+
+  type: ToolType.UTILITY,
+
+  dependencies: '',
+
+  functions: [initialFunction],
+
+};
+
+
+
+const App: React.FC = () => {
+
+  const [toolDefinition, setToolDefinition] = useState<ToolDefinition>(initialToolDefinition);
+
+  const [aiPrompt, setAiPrompt] = useState<string>('');
+
+  const [isGenerating, setIsGenerating] = useState<boolean>(false);
+
+  const [aiError, setAiError] = useState<string | null>(null);
+
+  
+
+  const generatedCode = useMemo<GeneratedCode | null>(() => {
+
+    try {
+
+      if (toolDefinition.name && toolDefinition.functions.length > 0 && toolDefinition.functions.every(f => f.name)) {
+
+        return generateAllCode(toolDefinition);
+
+      }
+
+      return null;
+
+    } catch (error) {
+
+      console.error("Error generating code:", error);
+
+      return null;
+
+    }
+
+  }, [toolDefinition]);
+
+
+
+  const loadNmapExample = () => {
+
+    setToolDefinition(nmapScannerExample);
+
+  };
+
+
+
+  const handleAiGenerate = async () => {
+
+    if (!aiPrompt.trim()) {
+
+      setAiError("Пожалуйста, введите описание инструмента.");
+
+      return;
+
+    }
+
+    setIsGenerating(true);
+
+    setAiError(null);
+
+    try {
+
+      const jsonString = await generateToolDefinitionFromPrompt(aiPrompt);
+
+      
+
+      // Бэкенд уже должен был очистить markdown, но на всякий случай
+
+      const cleanedJsonString = jsonString.replace(/^```json\s*|\s*```$/g, '').trim();
+
+      const newToolDefinition = JSON.parse(cleanedJsonString);
+
+      
+
+      // Добавим уникальные ID, так как AI их не генерирует
+
+      if (newToolDefinition.functions) {
+
+          newToolDefinition.functions.forEach((func: FunctionDefinition) => {
+
+          func.id = crypto.randomUUID();
+
+          if (func.parameters) {
+
+              func.parameters.forEach((param: any) => {
+
+              param.id = crypto.randomUUID();
+
+            });
+
+          } else {
+
+              func.parameters = []; // Убедимся, что параметры существуют
+
+          }
+
+        });
+
+      } else {
+
+          newToolDefinition.functions = []; // Убедимся, что функции существуют
+
+      }
+
+
+
+      setToolDefinition(newToolDefinition);
+
+
+
+    } catch (error) {
+
+      console.error("AI generation failed:", error);
+
+      setAiError(`Не удалось сгенерировать инструмент: ${error.message}. Проверьте консоль.`);
+
+    } finally {
+
+      setIsGenerating(false);
+
+    }
+
+  };
+
+
+
+  return (
+
+    <div className="min-h-screen bg-gray-900 text-gray-100 p-4 sm:p-6 lg:p-8">
+
+      <div className="max-w-screen-2xl mx-auto">
+
+        <header className="mb-8">
+
+          <div className="text-center">
+
+            <h1 className="text-4xl sm:text-5xl font-bold text-transparent bg-clip-text bg-gradient-to-r from-sky-400 to-blue-600">
+
+              Gemini CLI Tool Generator
+
+            </h1>
+
+            <p className="mt-2 text-lg text-gray-400">
+
+              Создайте кастомные расширения, которые Gemini сможет вызывать для решения ваших задач.
+
+            </p>
+
+          </div>
+
+          <div className="text-center mt-4">
+
+            <Button onClick={loadNmapExample} variant="secondary">
+
+              Загрузить пример: Nmap Scanner
+
+            </Button>
+
+          </div>
+
+        </header>
+
+        
+
+        <AiPrompt
+
+          prompt={aiPrompt}
+
+          setPrompt={setAiPrompt}
+
+          onGenerate={handleAiGenerate}
+
+          isLoading={isGenerating}
+
+          error={aiError}
+
+        />
+
+
+
+        <main className="grid grid-cols-1 xl:grid-cols-2 gap-8 mt-8">
+
+          <ToolForm toolDefinition={toolDefinition} setToolDefinition={setToolDefinition} />
+
+          <CodeOutput generatedCode={generatedCode} toolName={toolDefinition.name} />
+
+        </main>
+
+
+
+        <footer className="text-center mt-12 py-4 border-t border-gray-700">
+
+          <p className="text-gray-500">
+
+            Разработано с использованием React, Tailwind CSS и Gemini.
+
+          </p>
+
+        </footer>
+
+      </div>
+
+    </div>
+
+  );
+
+};
+
+
+
+export default App;
+
+
+
+
+

FastMCPToolGenerator/Dockerfile

@@ -0,0 +1,77 @@
+
+# Этап 1: Сборка React-фронтенда
+
+FROM node:18-slim AS build
+
+WORKDIR /app
+
+
+
+# Копируем package.json и устанавливаем npm зависимости
+
+COPY package.json package-lock.json ./
+
+RUN npm install
+
+
+
+# Копируем остальной код фронтенда
+
+COPY . .
+
+
+
+# Собираем production build (создает папку 'dist')
+
+RUN npm run build
+
+
+
+# Этап 2: Настройка Python-сервера (FastAPI)
+
+FROM python:3.10-slim
+
+WORKDIR /app
+
+
+
+# Установка переменных окружения
+
+ENV PYTHONUNBUFFERED 1
+
+ENV PYTHONDONTWRITEBYTECODE 1
+
+
+
+# Копируем Python-зависимости и устанавливаем их
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+
+
+# Копируем код бэкенда (FastAPI)
+
+COPY ./backend ./backend
+
+
+
+# Копируем собранный фронтенд из Этапа 1
+
+COPY --from=build /app/dist ./dist
+
+
+
+# Порт 7860 - стандартный для HF Spaces
+
+EXPOSE 7860
+
+ENV PORT=7860
+
+
+
+# Команда для запуска Uvicorn (FastAPI)
+
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]
+

FastMCPToolGenerator/GEMINI.md

@@ -0,0 +1,50 @@
+# Инструкция для Агента: Инструмент "nmap_scanner"
+
+## Описание
+
+Этот инструмент предоставляет прямой доступ к сетевому сканеру Nmap для проведения разведки и обнаружения хостов в сети. Он относится к типу **UTILITY**. Используй его для анализа сетевой безопасности, инвентаризации устройств и проверки открытых портов.
+
+## Функции
+
+### `nmap_scanner:run_scan`
+
+Запускает детальное сканирование Nmap на указанные цели. Позволяет гибко настраивать тип сканирования, определять службы и версии ПО.
+
+**Параметры:**
+- `targets` (*str*): Цели для сканирования (IP-адрес, домен, CIDR-диапазон). Например: '192.168.1.1', 'scanme.nmap.org', '10.0.0.0/24'. (обязательный)
+- `ports` (*str*): Порты для сканирования. Например: '21-25,80,443', '1-1024'. (обязательный)
+- `arguments` (*str*): Дополнительные аргументы командной строки Nmap. Например: '-sV -sC' для определения версий и запуска скриптов, или '-A' для агрессивного сканирования. (обязательный)
+
+**Возвращает:**
+*dict* - Результат сканирования в формате JSON, содержащий информацию о хостах, их состоянии, открытых портах, службах и версиях.
+
+---
+
+### `nmap_scanner:host_discovery`
+
+Быстро обнаруживает активные (включенные) хосты в указанной сети с помощью 'ping scan' (`-sn`), не проводя полного сканирования портов.
+
+**Параметры:**
+- `network_cidr` (*str*): Сетевой диапазон в формате CIDR для обнаружения хостов. Например: '192.168.1.0/24'. (обязательный)
+
+**Возвращает:**
+*list* - Список IP-адресов активных хостов, обнаруженных в сети.
+
+## Примеры использования
+
+**ВАЖНО:** Всегда используй формат `nmap_scanner:имя_функции()`.
+
+**Пример 1: Обнаружение всех активных устройств в локальной сети**
+```
+nmap_scanner:host_discovery(network_cidr="192.168.0.0/24")
+```
+
+**Пример 2: Быстрое сканирование популярных портов на конкретном хосте**
+```
+nmap_scanner:run_scan(targets="192.168.1.1", ports="1-1024", arguments="-T4")
+```
+
+**Пример 3: Агрессивное сканирование веб-сервера для определения ОС, служб и уязвимостей**
+```
+nmap_scanner:run_scan(targets="scanme.nmap.org", ports="80,443", arguments="-A -v")
+```

FastMCPToolGenerator/README0.md

@@ -0,0 +1,20 @@
+<div align="center">
+<img width="1200" height="475" alt="GHBanner" src="https://github.com/user-attachments/assets/0aa67016-6eaf-458a-adb2-6e31a0763ed6" />
+</div>
+
+# Run and deploy your AI Studio app
+
+This contains everything you need to run your app locally.
+
+View your app in AI Studio: https://ai.studio/apps/drive/1DWLDNsbZ8bO_lQPzuDVQB3cpW92HgYCC
+
+## Run Locally
+
+**Prerequisites:**  Node.js
+
+
+1. Install dependencies:
+   `npm install`
+2. Set the `GEMINI_API_KEY` in [.env.local](.env.local) to your Gemini API key
+3. Run the app:
+   `npm run dev`

FastMCPToolGenerator/backend/main.py

@@ -0,0 +1,164 @@
+import os
+import re
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+import google.generativeai as genai
+from google.generativeai.types import HarmCategory, HarmBlockThreshold
+
+# Получаем ключ из переменных окружения (HF Secrets)
+API_KEY = os.environ.get("GEMINI_API_KEY")
+
+if not API_KEY:
+    print("ВНИМАНИЕ: GEMINI_API_KEY не установлен в переменных окружения.")
+else:
+    genai.configure(api_key=API_KEY)
+
+app = FastAPI()
+
+# Модель для входящего запроса от фронтенда
+class PromptRequest(BaseModel):
+    prompt: str
+
+def get_ai_prompt(user_prompt: str):
+    return f"""
+Вы — эксперт по генерации JSON-определений инструментов (ToolDefinition) для FastMCP (Gemini CLI).
+Ваша задача — принять текстовое описание инструмента от пользователя и вернуть ТОЛЬКО JSON-структуру, соответствующую интерфейсу ToolDefinition.
+
+Интерфейс ToolDefinition (TypeScript):
+export enum ToolType {{
+  REST_API = 'REST_API',
+  CLI = 'CLI',
+  DATABASE = 'DATABASE',
+  CUSTOM = 'CUSTOM',
+  UTILITY = 'UTILITY',
+  CALCULATOR = 'CALCULATOR',
+  CONVERTER = 'CONVERTER'
+}}
+export enum ParameterType {{
+  STRING = 'str',
+  INTEGER = 'int',
+  FLOAT = 'float',
+  BOOLEAN = 'bool',
+  LIST = 'list',
+  DICTIONARY = 'dict'
+}}
+export interface ParameterDefinition {{
+  name: string;
+  type: ParameterType;
+  description: string;
+  required: boolean;
+}}
+export interface FunctionDefinition {{
+  name: string;
+  description: string;
+  parameters: ParameterDefinition[];
+  returnType: ParameterType;
+  returnDescription: string;
+}}
+export interface ToolDefinition {{
+  name: string;
+  type: ToolType;
+  dependencies: string;
+  functions: FunctionDefinition[];
+}}
+
+Правила:
+1.  НЕ добавляйте ID. Фронтенд сделает это.
+2.  Возвращайте ТОЛЬКО JSON-код. Без markdown, без "вот ваш JSON".
+3.  Имена функций и параметров должны быть в snake_case.
+4.  Тип (ToolType) должен быть наиболее подходящим (часто это UTILITY или CLI).
+5.  Dependencies (зависимости) должны быть пустыми (""), если не указано иное (например, для 'nmap' нужна 'python-nmap').
+
+Пример запроса пользователя:
+"Инструмент для получения текущей погоды в городе."
+
+Пример вашего ИДЕАЛЬНОГО ответа (ТОЛЬКО JSON):
+{{
+  "name": "weather_tool",
+  "type": "REST_API",
+  "dependencies": "requests",
+  "functions": [
+    {{
+      "name": "get_current_weather",
+      "description": "Получает текущую погоду для указанного города.",
+      "parameters": [
+        {{
+          "name": "city_name",
+          "type": "str",
+          "description": "Название города, для которого нужно получить погоду.",
+          "required": true
+        }}
+      ],
+      "returnType": "dict",
+      "returnDescription": "Словарь с данными о погоде (температура, влажность и т.д.)."
+    }}
+  ]
+}}
+---
+ЗАПРОС ПОЛЬЗОВАТЕЛЯ:
+"{user_prompt}"
+
+ВАШ ОТВЕТ (ТОЛЬКО JSON):
+"""
+
+generation_config = {
+    "temperature": 0.7,
+    "top_p": 1.0,
+    "top_k": 32,
+    "max_output_tokens": 4096,
+}
+
+safety_settings = [
+    {"category": HarmCategory.HARM_CATEGORY_HARASSMENT, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+    {"category": HarmCategory.HARM_CATEGORY_HATE_SPEECH, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+    {"category": HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+    {"category": HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, "threshold": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE},
+]
+
+@app.post("/api/generate")
+async def handle_generate(request: PromptRequest):
+    if not API_KEY:
+        raise HTTPException(status_code=500, detail="GEMINI_API_KEY не настроен на сервере.")
+
+    try:
+        model = genai.GenerativeModel(
+            model_name="gemini-1.5-pro-latest",
+            generation_config=generation_config,
+            safety_settings=safety_settings
+        )
+        
+        prompt_parts = [get_ai_prompt(request.prompt)]
+        response = model.generate_content(prompt_parts)
+        
+        json_string = response.text
+        
+        cleaned_json_string = re.sub(r'^```json\s*|\s*```$', '', json_string, flags=re.MULTILINE).strip()
+        
+        return {"jsonString": cleaned_json_string}
+
+    except Exception as e:
+        print(f"Ошибка вызова Gemini API: {e}")
+        raise HTTPException(status_code=500, detail=f"Ошибка генерации AI: {str(e)}")
+
+# --- Настройки для развертывания на Hugging Face Spaces/Docker ---
+# PORT=7860 устанавливается Hugging Face при запуске контейнера
+IS_HUGGINGFACE_SPACE = os.environ.get("PORT") == "7860"
+
+if IS_HUGGINGFACE_SPACE:
+    
+    # Монтируем статические файлы (React build)
+    app.mount("/assets", StaticFiles(directory="/app/dist/assets"), name="assets")
+
+    @app.get("/{full_path:path}")
+    async def serve_react_app(full_path: str):
+        # Обслуживаем index.html для всех non-API маршрутов
+        return FileResponse("/app/dist/index.html")
+        
+else:
+    # При локальной разработке (Vite) FastAPI отвечает ТОЛЬКО за API.
+    # Статику раздает Vite (порт 3000).
+    print("ℹ️ Режим локальной разработки. Статические файлы обслуживаются Vite.")
+
+

FastMCPToolGenerator/components/AiPrompt.tsx

@@ -0,0 +1,52 @@
+
+import React from 'react';
+import Card from './ui/Card';
+import Textarea from './ui/Textarea';
+import Button from './ui/Button';
+import Label from './ui/Label';
+
+interface AiPromptProps {
+  prompt: string;
+  setPrompt: (value: string) => void;
+  onGenerate: () => void;
+  isLoading: boolean;
+  error: string | null;
+}
+
+const AiPrompt: React.FC<AiPromptProps> = ({ prompt, setPrompt, onGenerate, isLoading, error }) => {
+  return (
+    <Card className="mb-8 border-sky-500 border-2 shadow-lg shadow-sky-500/10">
+      <h2 className="text-2xl font-bold mb-4 text-sky-400">
+        ✨ Создание с помощью AI
+      </h2>
+      <p className="text-gray-400 mb-4 text-sm">
+        Опишите инструмент, который вы хотите создать, на естественном языке. AI проанализирует ваш запрос и автоматически заполнит форму ниже.
+      </p>
+      
+      <div>
+        <Label htmlFor="ai-prompt">Ваш запрос:</Label>
+        <Textarea
+          id="ai-prompt"
+          value={prompt}
+          onChange={(e) => setPrompt(e.target.value)}
+          placeholder="Например: 'Инструмент для получения текущей погоды в городе' или 'Утилита для работы с файлами: чтение, запись и удаление'"
+          rows={3}
+          disabled={isLoading}
+        />
+      </div>
+      
+      <div className="mt-4 flex items-center justify-between">
+        <Button onClick={onGenerate} disabled={isLoading}>
+          {isLoading ? 'Генерация...' : 'Сгенерировать'}
+        </Button>
+        {error && <p className="text-red-400 text-sm ml-4">{error}</p>}
+      </div>
+    </Card>
+  );
+};
+
+export default AiPrompt;
+
+
+
+

FastMCPToolGenerator/components/CodeOutput.tsx

@@ -0,0 +1,340 @@
+import React, { useState } from 'react';
+
+import { GeneratedCode } from '../types';
+
+import JSZip from 'jszip'; // Импортируем JSZip из npm
+
+
+
+interface CodeOutputProps {
+
+  generatedCode: GeneratedCode | null;
+
+  toolName: string;
+
+}
+
+
+
+type Tab = 'setup.py' | 'server.py' | '.gemini/settings.json' | 'GEMINI.md' | 'Инструкция' | 'Примеры';
+
+
+
+const CodeOutput: React.FC<CodeOutputProps> = ({ generatedCode, toolName }) => {
+
+  const [activeTab, setActiveTab] = useState<Tab>('Примеры');
+
+  const [copiedTab, setCopiedTab] = useState<Tab | null>(null);
+
+
+
+  const handleCopy = (content: string, tab: Tab) => {
+
+    navigator.clipboard.writeText(content);
+
+    setCopiedTab(tab);
+
+    setTimeout(() => setCopiedTab(null), 2000);
+
+  };
+
+  
+
+  const handleDownloadZip = () => {
+
+    if (!generatedCode || !toolName) return;
+
+    
+
+    const zip = new JSZip(); // Теперь JSZip импортирован
+
+    const rootFolder = zip.folder(toolName);
+
+    if (!rootFolder) return;
+
+
+
+    rootFolder.file('setup.py', generatedCode.setupPy);
+
+    rootFolder.file('server.py', generatedCode.serverPy);
+
+    rootFolder.file('GEMINI.md', generatedCode.geminiMd);
+
+    
+
+    const geminiFolder = rootFolder.folder('.gemini');
+
+    if (geminiFolder) {
+
+        geminiFolder.file('settings.json', generatedCode.settingsJson);
+
+    }
+
+    
+
+    zip.generateAsync({ type: 'blob' }).then(content => {
+
+      const link = document.createElement('a');
+
+      link.href = URL.createObjectURL(content);
+
+      link.download = `${toolName}.zip`; 
+
+      document.body.appendChild(link);
+
+      link.click();
+
+      document.body.removeChild(link);
+
+    });
+
+  };
+
+
+
+  const tabs: Tab[] = ['Примеры', 'GEMINI.md', 'server.py', 'setup.py', '.gemini/settings.json', 'Инструкция'];
+
+
+
+  const getContentForTab = (tab: Tab): string => {
+
+    if (!generatedCode) return "Сгенерируйте код, заполнив форму слева."; 
+
+    switch (tab) {
+
+      case 'setup.py': return generatedCode.setupPy;
+
+      case 'server.py': return generatedCode.serverPy;
+
+      case '.gemini/settings.json': return generatedCode.settingsJson;
+
+      case 'GEMINI.md': return generatedCode.geminiMd;
+
+      case 'Примеры': return generatedCode.examplesMd;
+
+      case 'Инструкция': return getInstructions(toolName, generatedCode);
+
+      default: return '';
+
+    }
+
+  };
+
+
+
+  const getLanguageForTab = (tab: Tab): string => {
+
+      switch(tab) {
+
+          case 'setup.py':
+
+          case 'server.py':
+
+              return 'python';
+
+          case '.gemini/settings.json':
+
+              return 'json';
+
+          case 'GEMINI.md':
+
+          case 'Инструкция':
+
+          case 'Примеры':
+
+              return 'markdown';
+
+          default:
+
+              return 'plaintext';
+
+      }
+
+  }
+
+
+
+  const getInstructions = (toolName: string, code: GeneratedCode): string => {
+
+    const primaryFunctionMatch = code.serverPy?.match(/def\s+([a-zA-Z0-9_]+)\(/);
+
+    const primaryFunction = primaryFunctionMatch && primaryFunctionMatch[1] ? primaryFunctionMatch[1] : 'your_function';
+
+
+
+    return `
+
+# Набор Инструкций для Создания Нового Инструмента
+
+
+
+## 1. 📂 Структура проекта
+
+Создайте следующую структуру папок и файлов (или просто нажмите "Скачать .zip"):
+
+
+
+${toolName}/
+
+├── .gemini/
+
+│   └── settings.json
+
+├── GEMINI.md
+
+├── setup.py
+
+└── server.py
+
+
+
+## 2. 🐍 Содержимое файлов
+
+Скопируйте содержимое из соответствующих вкладок в созданные файлы.
+
+
+
+## 3. 📦 Установка и запуск
+
+Откройте терминал в папке \`${toolName}\` и выполните:
+
+
+
+\`\`\`bash
+
+# Установка зависимостей и инструмента в режиме разработки
+
+pip install -e .
+
+
+
+# Запуск инструмента (Gemini CLI сделает это автоматически)
+
+# Для ручной проверки можно запустить:
+
+python server.py
+
+\`\`\`
+
+
+
+## 4. 🚀 Использование в Gemini CLI
+
+После установки Gemini CLI автоматически обнаружит ваш инструмент.
+
+См. вкладку "Примеры", чтобы увидеть, как ваши запросы на естественном языке будут превращаться в вызовы функций.
+
+
+
+### ⚠️ Правило вызова
+
+\`\`\`
+
+${toolName}:${primaryFunction}
+
+\`\`\`
+
+`;
+
+  };
+
+
+
+  return (
+
+    <div className="bg-gray-800/50 border border-gray-700 rounded-lg overflow-hidden h-full flex flex-col">
+
+      <div className="flex-shrink-0 bg-gray-900/70 border-b border-gray-700 flex justify-between items-center pr-2">
+
+        <nav className="flex space-x-1 p-1" aria-label="Tabs">
+
+          {tabs.map(tab => (
+
+            <button
+
+              key={tab}
+
+              onClick={() => setActiveTab(tab)}
+
+              className={`whitespace-nowrap px-3 py-2 text-sm font-medium rounded-md transition ${
+
+                activeTab === tab
+
+                  ? 'bg-sky-600 text-white'
+
+                  : 'text-gray-400 hover:bg-gray-700 hover:text-gray-200'
+
+              }`}
+
+            >
+
+              {tab}
+
+            </button>
+
+          ))}
+
+        </nav>
+
+        {generatedCode && (
+
+           <button
+
+             onClick={handleDownloadZip}
+
+             className="bg-sky-600 hover:bg-sky-500 text-white px-3 py-1.5 rounded-md text-xs font-semibold transition disabled:opacity-50"
+
+             disabled={!generatedCode}
+
+           >
+
+             Скачать .zip
+
+           </button>
+
+        )}
+
+      </div>
+
+      <div className="relative flex-grow min-h-0">
+
+        <pre className="h-full overflow-auto p-4 text-sm font-mono bg-gray-800">
+
+          <code className={`language-${getLanguageForTab(activeTab)}`}>
+
+            {getContentForTab(activeTab)}
+
+          </code>
+
+        </pre>
+
+        {activeTab !== 'Инструкция' && generatedCode && (
+
+           <button
+
+             onClick={() => handleCopy(getContentForTab(activeTab), activeTab)}
+
+             className="absolute top-4 right-4 bg-gray-700 hover:bg-gray-600 text-gray-200 px-3 py-1 rounded-md text-xs transition"
+
+           >
+
+             {copiedTab === activeTab ? 'Скопировано!' : 'Копировать'}
+
+           </button>
+
+        )}
+
+      </div>
+
+    </div>
+
+  );
+
+};
+
+
+
+export default CodeOutput;
+
+
+

FastMCPToolGenerator/components/FunctionEditor.tsx

@@ -0,0 +1,146 @@
+
+import React from 'react';
+import { FunctionDefinition, ParameterDefinition, ParameterType } from '../types';
+import { PARAMETER_TYPES, PARAMETER_TYPE_DESCRIPTIONS } from '../constants';
+import Input from './ui/Input';
+import Textarea from './ui/Textarea';
+import Select from './ui/Select';
+import Label from './ui/Label';
+import Button from './ui/Button';
+import Card from './ui/Card';
+
+interface FunctionEditorProps {
+  func: FunctionDefinition;
+  updateFunction: (func: FunctionDefinition) => void;
+  removeFunction: () => void;
+  isOnlyFunction: boolean;
+}
+
+const ParameterRow: React.FC<{
+  param: ParameterDefinition;
+  updateParameter: (param: ParameterDefinition) => void;
+  removeParameter: () => void;
+}> = ({ param, updateParameter, removeParameter }) => {
+  
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) => {
+    const { name, value, type } = e.target;
+    const isCheckbox = type === 'checkbox';
+    const checked = isCheckbox ? (e.target as HTMLInputElement).checked : undefined;
+    
+    updateParameter({
+      ...param,
+      [name]: isCheckbox ? checked : value
+    });
+  };
+
+  return (
+    <div className="grid grid-cols-1 md:grid-cols-[1fr,1fr,2fr,auto,auto] gap-2 items-center p-2 bg-gray-900/50 rounded">
+      <Input name="name" value={param.name} onChange={handleChange} placeholder="Имя параметра" />
+      <div>
+        <Select name="type" value={param.type} onChange={handleChange}>
+          {PARAMETER_TYPES.map(t => <option key={t} value={t} title={PARAMETER_TYPE_DESCRIPTIONS[t]}>{t}</option>)}
+        </Select>
+        <p className="text-xs text-gray-400 mt-1 pl-1">{PARAMETER_TYPE_DESCRIPTIONS[param.type]}</p>
+      </div>
+      <Input name="description" value={param.description} onChange={handleChange} placeholder="Описание" />
+      <label className="flex items-center space-x-2 text-sm text-gray-300 justify-center">
+        <input type="checkbox" name="required" checked={param.required} onChange={handleChange} className="rounded bg-gray-700 border-gray-600 text-sky-500 focus:ring-sky-500"/>
+        <span>Req.</span>
+      </label>
+      <Button onClick={removeParameter} variant="danger" className="px-2 py-1 text-xs">X</Button>
+    </div>
+  );
+};
+
+
+const FunctionEditor: React.FC<FunctionEditorProps> = ({ func, updateFunction, removeFunction, isOnlyFunction }) => {
+  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => {
+    updateFunction({ ...func, [e.target.name]: e.target.value });
+  };
+
+  const addParameter = () => {
+    const newParam: ParameterDefinition = {
+      id: crypto.randomUUID(),
+      name: `param_${func.parameters.length + 1}`,
+      type: ParameterType.STRING,
+      description: '',
+      required: true
+    };
+    updateFunction({ ...func, parameters: [...func.parameters, newParam] });
+  };
+
+  const updateParameter = (updatedParam: ParameterDefinition) => {
+    updateFunction({
+      ...func,
+      parameters: func.parameters.map(p => p.id === updatedParam.id ? updatedParam : p)
+    });
+  };
+  
+  const removeParameter = (id: string) => {
+    updateFunction({
+      ...func,
+      parameters: func.parameters.filter(p => p.id !== id)
+    });
+  };
+
+  return (
+    <Card>
+      <div className="flex justify-between items-start mb-4">
+        <div className="flex-grow">
+          <Label htmlFor={`func-name-${func.id}`}>Имя функции</Label>
+          <Input id={`func-name-${func.id}`} name="name" value={func.name} onChange={handleInputChange} />
+        </div>
+        <Button onClick={removeFunction} variant="danger" disabled={isOnlyFunction} className="ml-4 mt-6">
+          Удалить функцию
+        </Button>
+      </div>
+
+      <div>
+        <Label htmlFor={`func-desc-${func.id}`}>Описание функции</Label>
+        <Textarea id={`func-desc-${func.id}`} name="description" value={func.description} onChange={handleInputChange} />
+      </div>
+
+      <div className="mt-4">
+        <h4 className="font-semibold text-gray-300 mb-2">Параметры</h4>
+        <div className="flex flex-col gap-2">
+            {func.parameters.length > 0 && (
+                <div className="hidden md:grid md:grid-cols-[1fr,1fr,2fr,auto,auto] gap-2 text-xs text-gray-400 px-2">
+                    <span>Имя</span>
+                    <span>РўРёРї</span>
+                    <span>Описание</span>
+                    <span className="text-center">РћР±СЏР·.</span>
+                </div>
+            )}
+            {func.parameters.map((param) => (
+                <ParameterRow 
+                    key={param.id} 
+                    param={param} 
+                    updateParameter={updateParameter}
+                    removeParameter={() => removeParameter(param.id)}
+                />
+            ))}
+        </div>
+        <Button onClick={addParameter} variant="secondary" className="mt-3 text-xs">+ Добавить параметр</Button>
+      </div>
+      
+      <div className="mt-4 grid grid-cols-1 md:grid-cols-2 gap-4">
+        <div>
+          <Label htmlFor={`func-return-type-${func.id}`}>Тип возвращаемого значения</Label>
+          <Select id={`func-return-type-${func.id}`} name="returnType" value={func.returnType} onChange={handleInputChange}>
+            {PARAMETER_TYPES.map(t => <option key={t} value={t}>{t}</option>)}
+          </Select>
+        </div>
+        <div>
+          <Label htmlFor={`func-return-desc-${func.id}`}>Описание возвращаемого значения</Label>
+          <Input id={`func-return-desc-${func.id}`} name="returnDescription" value={func.returnDescription} onChange={handleInputChange} />
+        </div>
+      </div>
+    </Card>
+  );
+};
+
+export default FunctionEditor;
+
+
+
+

FastMCPToolGenerator/components/ToolForm.tsx

@@ -0,0 +1,115 @@
+
+import React from 'react';
+import { ToolDefinition, FunctionDefinition, ToolType, ParameterType } from '../types';
+import { TOOL_TYPES } from '../constants';
+import FunctionEditor from './FunctionEditor';
+import Input from './ui/Input';
+import Select from './ui/Select';
+import Label from './ui/Label';
+import Button from './ui/Button';
+import Card from './ui/Card';
+
+interface ToolFormProps {
+  toolDefinition: ToolDefinition;
+  setToolDefinition: React.Dispatch<React.SetStateAction<ToolDefinition>>;
+}
+
+const ToolForm: React.FC<ToolFormProps> = ({ toolDefinition, setToolDefinition }) => {
+  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>) => {
+    const { name, value } = e.target;
+    setToolDefinition(prev => ({ ...prev, [name]: value }));
+  };
+
+  const addFunction = () => {
+    const newFunction: FunctionDefinition = {
+      id: crypto.randomUUID(),
+      name: `new_function_${toolDefinition.functions.length + 1}`,
+      description: 'Описание новой функции.',
+      parameters: [],
+      returnType: ParameterType.STRING,
+      returnDescription: 'Описание возвращаемого значения.'
+    };
+    setToolDefinition(prev => ({
+      ...prev,
+      functions: [...prev.functions, newFunction]
+    }));
+  };
+
+  const updateFunction = (updatedFunction: FunctionDefinition) => {
+    setToolDefinition(prev => ({
+      ...prev,
+      functions: prev.functions.map(fn => fn.id === updatedFunction.id ? updatedFunction : fn)
+    }));
+  };
+  
+  const removeFunction = (id: string) => {
+    setToolDefinition(prev => ({
+      ...prev,
+      functions: prev.functions.filter(fn => fn.id !== id)
+    }));
+  };
+
+  return (
+    <div className="flex flex-col gap-6">
+      <Card>
+        <h2 className="text-2xl font-bold mb-4 text-sky-400">1. Конфигурация инструмента</h2>
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+          <div>
+            <Label htmlFor="name">Название инструмента (Tool Name)</Label>
+            <Input 
+              id="name" 
+              name="name" 
+              value={toolDefinition.name} 
+              onChange={handleInputChange} 
+              placeholder="e.g., web_scraper" 
+            />
+          </div>
+          <div>
+            <Label htmlFor="type">Тип инструмента (Tool Type)</Label>
+            <Select id="type" name="type" value={toolDefinition.type} onChange={handleInputChange}>
+              {TOOL_TYPES.map(type => (
+                <option key={type} value={type}>{type}</option>
+              ))}
+            </Select>
+          </div>
+          <div className="md:col-span-2">
+            <Label htmlFor="dependencies">Зависимости (Dependencies)</Label>
+            <Input
+              id="dependencies"
+              name="dependencies"
+              value={toolDefinition.dependencies}
+              onChange={handleInputChange}
+              placeholder="e.g., requests, beautifulsoup4"
+            />
+             <p className="text-xs text-gray-500 mt-1">Перечислите через запятую или пробел.</p>
+          </div>
+        </div>
+      </Card>
+      
+      <div className="flex flex-col gap-6">
+        <h2 className="text-2xl font-bold text-sky-400">2. Функции</h2>
+        {toolDefinition.functions.map((func, index) => (
+          <FunctionEditor
+            key={func.id}
+            func={func}
+            updateFunction={updateFunction}
+            removeFunction={() => removeFunction(func.id)}
+            isOnlyFunction={toolDefinition.functions.length === 1}
+          />
+        ))}
+      </div>
+
+      <div className="mt-2">
+        <Button onClick={addFunction} variant="secondary">
+          + Добавить функцию
+        </Button>
+      </div>
+    </div>
+  );
+};
+
+export default ToolForm;
+
+
+
+

FastMCPToolGenerator/components/ui/Button.tsx

@@ -0,0 +1,28 @@
+
+import React from 'react';
+
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+  variant?: 'primary' | 'secondary' | 'danger';
+}
+
+const Button: React.FC<ButtonProps> = ({ variant = 'primary', className, children, ...props }) => {
+  const baseClasses = "px-4 py-2 rounded-md font-semibold text-sm transition-all focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-offset-gray-900 disabled:opacity-50 disabled:cursor-not-allowed";
+  
+  const variantClasses = {
+    primary: 'bg-sky-600 text-white hover:bg-sky-500 focus:ring-sky-500',
+    secondary: 'bg-gray-700 text-gray-200 hover:bg-gray-600 focus:ring-gray-500',
+    danger: 'bg-red-600 text-white hover:bg-red-500 focus:ring-red-500',
+  };
+
+  return (
+    <button className={`${baseClasses} ${variantClasses[variant]} ${className}`} {...props}>
+      {children}
+    </button>
+  );
+};
+
+export default Button;
+
+
+
+

FastMCPToolGenerator/components/ui/Card.tsx

@@ -0,0 +1,21 @@
+
+import React from 'react';
+
+interface CardProps {
+    children: React.ReactNode;
+    className?: string;
+}
+
+const Card: React.FC<CardProps> = ({ children, className }) => {
+    return (
+        <div className={`bg-gray-800/50 border border-gray-700 rounded-lg p-6 ${className}`}>
+            {children}
+        </div>
+    );
+};
+
+export default Card;
+
+
+
+

FastMCPToolGenerator/components/ui/Input.tsx

@@ -0,0 +1,19 @@
+
+import React from 'react';
+
+type InputProps = React.InputHTMLAttributes<HTMLInputElement>;
+
+const Input: React.FC<InputProps> = (props) => {
+  return (
+    <input
+      {...props}
+      className="w-full bg-gray-800 border border-gray-600 rounded-md px-3 py-2 text-gray-200 placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-sky-500 focus:border-sky-500 transition"
+    />
+  );
+};
+
+export default Input;
+
+
+
+

FastMCPToolGenerator/components/ui/Label.tsx

@@ -0,0 +1,16 @@
+
+import React from 'react';
+
+type LabelProps = React.LabelHTMLAttributes<HTMLLabelElement>;
+
+const Label: React.FC<LabelProps> = (props) => {
+  return (
+    <label {...props} className="block text-sm font-medium text-gray-300 mb-1" />
+  );
+};
+
+export default Label;
+
+
+
+

FastMCPToolGenerator/components/ui/Select.tsx

@@ -0,0 +1,28 @@
+
+import React from 'react';
+
+type SelectProps = React.SelectHTMLAttributes<HTMLSelectElement>;
+
+const Select: React.FC<SelectProps> = (props) => {
+  return (
+    <select
+      {...props}
+      className="w-full bg-gray-800 border border-gray-600 rounded-md px-3 py-2 text-gray-200 focus:outline-none focus:ring-2 focus:ring-sky-500 focus:border-sky-500 transition appearance-none"
+      style={{
+        backgroundImage: `url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 20 20'%3e%3cpath stroke='%236b7280' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' d='M6 8l4 4 4-4'/%3e%3c/svg%3e")`,
+        backgroundPosition: 'right 0.5rem center',
+        backgroundRepeat: 'no-repeat',
+        backgroundSize: '1.5em 1.5em',
+        paddingRight: '2.5rem',
+      }}
+    >
+      {props.children}
+    </select>
+  );
+};
+
+export default Select;
+
+
+
+

FastMCPToolGenerator/components/ui/Textarea.tsx

@@ -0,0 +1,20 @@
+
+import React from 'react';
+
+type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+
+const Textarea: React.FC<TextareaProps> = (props) => {
+  return (
+    <textarea
+      {...props}
+      className="w-full bg-gray-800 border border-gray-600 rounded-md px-3 py-2 text-gray-200 placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-sky-500 focus:border-sky-500 transition"
+      rows={2}
+    />
+  );
+};
+
+export default Textarea;
+
+
+
+

FastMCPToolGenerator/constants.ts

@@ -0,0 +1,18 @@
+
+import { ToolType, ParameterType } from './types';
+
+export const TOOL_TYPES: ToolType[] = Object.values(ToolType);
+export const PARAMETER_TYPES: ParameterType[] = Object.values(ParameterType);
+
+export const PARAMETER_TYPE_DESCRIPTIONS: Record<ParameterType, string> = {
+  [ParameterType.STRING]: 'Текстовая строка (e.g., "hello world").',
+  [ParameterType.INTEGER]: 'Целое число (e.g., 10, -5).',
+  [ParameterType.FLOAT]: 'Число с плавающей точкой (e.g., 3.14).',
+  [ParameterType.BOOLEAN]: 'Логическое значение (True или False).',
+  [ParameterType.LIST]: 'Упорядоченный список элементов (e.g., ["a", "b"]).',
+  [ParameterType.DICTIONARY]: 'Словарь пар ключ-значение (e.g., {"key": "value"}).'
+};
+
+
+
+

FastMCPToolGenerator/dist/index.html

@@ -0,0 +1,46 @@
+
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>FastMCP Tool Generator</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+    <style>
+      /* Custom scrollbar for webkit browsers */
+      ::-webkit-scrollbar {
+        width: 8px;
+        height: 8px;
+      }
+      ::-webkit-scrollbar-track {
+        background: #1f2937; /* bg-gray-800 */
+      }
+      ::-webkit-scrollbar-thumb {
+        background: #4b5563; /* bg-gray-600 */
+        border-radius: 4px;
+      }
+      ::-webkit-scrollbar-thumb:hover {
+        background: #6b7280; /* bg-gray-500 */
+      }
+    </style>
+
+<link rel="stylesheet" href="/index.css">
+  <script type="importmap">
+{
+  "imports": {
+    "react": "https://aistudiocdn.com/react@^19.2.0",
+    "react-dom/": "https://aistudiocdn.com/react-dom@^19.2.0/",
+    "react/": "https://aistudiocdn.com/react@^19.2.0/",
+    "@google/genai": "https://aistudiocdn.com/@google/genai@^1.29.0"
+  }
+}
+</script>
+  <script type="module" crossorigin src="/assets/index-CjZgBbLF.js"></script>
+</head>
+  <body class="bg-gray-900 text-gray-100">
+    <div id="root"></div>
+  </body>
+</html>
+
+

FastMCPToolGenerator/examples.ts

@@ -0,0 +1,60 @@
+
+import { ToolDefinition, ToolType, ParameterType } from './types';
+
+export const nmapScannerExample: ToolDefinition = {
+  name: 'nmap_scanner',
+  type: ToolType.UTILITY,
+  dependencies: 'python-nmap',
+  functions: [
+    {
+      id: 'nmap-func-1',
+      name: 'run_scan',
+      description: 'Запускает сканирование Nmap на указанные цели с заданными аргументами. Позволяет выполнять гибкую разведку сети.',
+      parameters: [
+        {
+          id: 'nmap-param-1',
+          name: 'targets',
+          type: ParameterType.STRING,
+          description: "Цели для сканирования (IP, домен, CIDR). Например: '192.168.1.1', 'scanme.nmap.org', '10.0.0.0/24'.",
+          required: true,
+        },
+        {
+          id: 'nmap-param-2',
+          name: 'ports',
+          type: ParameterType.STRING,
+          description: "Порты для сканирования. Например: '21-25,80,443,8080'.",
+          required: true,
+        },
+        {
+          id: 'nmap-param-3',
+          name: 'arguments',
+          type: ParameterType.STRING,
+          description: "Дополнительные аргументы Nmap для тонкой настройки сканирования. Например: '-sV -sC -O'.",
+          required: true,
+        },
+      ],
+      returnType: ParameterType.DICTIONARY,
+      returnDescription: 'Результат сканирования в формате JSON, содержащий информацию о хостах, портах, службах и их версиях.',
+    },
+    {
+      id: 'nmap-func-2',
+      name: 'host_discovery',
+      description: 'Обнаруживает активные хосты в указанной сети (ping scan), не проводя сканирование портов.',
+      parameters: [
+        {
+          id: 'nmap-param-4',
+          name: 'network_cidr',
+          type: ParameterType.STRING,
+          description: "Сетевой диапазон в формате CIDR для обнаружения хостов. Например: '192.168.1.0/24'.",
+          required: true,
+        },
+      ],
+      returnType: ParameterType.LIST,
+      returnDescription: 'Список IP-адресов активных хостов, обнаруженных в сети.',
+    },
+  ],
+};
+
+
+
+

FastMCPToolGenerator/index.html

@@ -0,0 +1,45 @@
+
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>FastMCP Tool Generator</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+    <style>
+      /* Custom scrollbar for webkit browsers */
+      ::-webkit-scrollbar {
+        width: 8px;
+        height: 8px;
+      }
+      ::-webkit-scrollbar-track {
+        background: #1f2937; /* bg-gray-800 */
+      }
+      ::-webkit-scrollbar-thumb {
+        background: #4b5563; /* bg-gray-600 */
+        border-radius: 4px;
+      }
+      ::-webkit-scrollbar-thumb:hover {
+        background: #6b7280; /* bg-gray-500 */
+      }
+    </style>
+  <script type="importmap">
+{
+  "imports": {
+    "react": "https://aistudiocdn.com/react@^19.2.0",
+    "react-dom/": "https://aistudiocdn.com/react-dom@^19.2.0/",
+    "react/": "https://aistudiocdn.com/react@^19.2.0/",
+    "@google/genai": "https://aistudiocdn.com/@google/genai@^1.29.0"
+  }
+}
+</script>
+<link rel="stylesheet" href="/index.css">
+</head>
+  <body class="bg-gray-900 text-gray-100">
+    <div id="root"></div>
+    <script type="module" src="/index.tsx"></script>
+  </body>
+</html>
+
+

FastMCPToolGenerator/index.tsx

@@ -0,0 +1,20 @@
+
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+
+const rootElement = document.getElementById('root');
+if (!rootElement) {
+  throw new Error("Could not find root element to mount to");
+}
+
+const root = ReactDOM.createRoot(rootElement);
+root.render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);
+
+
+
+

FastMCPToolGenerator/metadata.json

@@ -0,0 +1,7 @@
+{
+  "name": "Copy of Copy of Copy of FastMCP Tool Generator",
+  "description": "A web application to generate complete, self-contained, and deployable FastMCP tool boilerplates for Gemini CLI based on user's technical requirements. It creates all necessary files including server logic, setup configuration, and agent instructions.",
+  "requestFramePermissions": []
+}
+
+

FastMCPToolGenerator/package.json

@@ -0,0 +1,42 @@
+
+{
+  "name": "fastmcp-tool-generator-hf",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "autoprefixer": "^10.4.19",
+    "axios": "^1.7.2",
+    "highlight.js": "^11.9.0",
+    "jszip": "^3.10.1",
+    "postcss": "^8.4.38",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-hot-toast": "^2.4.1",
+    "tailwindcss": "^3.4.4"
+  },
+  "devDependencies": {
+    "@types/highlight.js": "^10.1.0",
+    "@types/jszip": "^3.10.1",
+    "@types/react": "^18.2.66",
+    "@types/react-dom": "^18.2.22",
+    "@typescript-eslint/eslint-plugin": "^7.2.0",
+    "@typescript-eslint/parser": "^7.2.0",
+    "@vitejs/plugin-react": "^4.2.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.6",
+    "typescript": "^5.2.2",
+    "vite": "^5.2.0"
+  }
+}
+
+
+
+
+

FastMCPToolGenerator/requirements.txt

@@ -0,0 +1,11 @@
+
+fastapi
+
+uvicorn[standard]
+
+google-generativeai
+
+pydantic
+
+python-dotenv
+

FastMCPToolGenerator/services/aiService.ts

@@ -0,0 +1,71 @@
+
+import { ToolDefinition, FunctionDefinition } from '../types';
+
+
+
+export async function generateToolDefinitionFromPrompt(prompt: string): Promise<string> {
+
+  console.log("Отправка запроса на бэкенд /api/generate...");
+
+
+
+  try {
+
+    const response = await fetch('/api/generate', {
+
+      method: 'POST',
+
+      headers: {
+
+        'Content-Type': 'application/json',
+
+      },
+
+      body: JSON.stringify({ prompt: prompt }),
+
+    });
+
+
+
+    if (!response.ok) {
+
+      const errorData = await response.json();
+
+      throw new Error(errorData.detail || `HTTP error! status: ${response.status}`);
+
+    }
+
+
+
+    const data = await response.json();
+
+    
+
+    // Бэкенд теперь возвращает объект { jsonString: "..." }
+
+    if (typeof data.jsonString !== 'string') {
+
+        throw new Error("Бэкенд вернул неверный формат ответа.");
+
+    }
+
+
+
+    return data.jsonString;
+
+
+
+  } catch (error) {
+
+    console.error("Ошибка при вызове бэкенда /api/generate:", error);
+
+    throw new Error(`Не удалось связаться с сервером: ${error.message}`);
+
+  }
+
+}
+
+
+
+
+

FastMCPToolGenerator/services/codeGenerator.ts

@@ -0,0 +1,428 @@
+
+import { ToolDefinition, FunctionDefinition, ParameterDefinition, ParameterType, GeneratedCode } from '../types';
+
+const toPythonType = (type: ParameterType): string => {
+  const mapping: Record<ParameterType, string> = {
+    [ParameterType.STRING]: 'str',
+    [ParameterType.INTEGER]: 'int',
+    [ParameterType.FLOAT]: 'float',
+    [ParameterType.BOOLEAN]: 'bool',
+    [ParameterType.LIST]: 'list',
+    [ParameterType.DICTIONARY]: 'dict',
+  };
+  return mapping[type] || 'Any';
+};
+
+const generateSetupPy = (def: ToolDefinition): string => {
+  const dependencies = def.dependencies.split(/[\s,]+/).filter(Boolean);
+  const installRequires = dependencies.length > 0
+    ? `install_requires=${JSON.stringify(dependencies)},`
+    : '';
+
+  return `
+from setuptools import setup, find_packages
+
+setup(
+    name='${def.name}',
+    version='0.1.0',
+    packages=find_packages(),
+    ${installRequires}
+    entry_points={
+        'gemini_tools': [
+            '${def.name} = server:main',
+        ],
+    },
+)
+`.trim();
+};
+
+const generateServerPy = (def: ToolDefinition): string => {
+  const functionStrings = def.functions.map(func => generateFunction(def, func)).join('\n\n');
+  const imports = def.name === 'nmap_scanner' ? 'import nmap' : '# TODO: Добавьте необходимые импорты';
+
+  return `
+# -*- coding: utf-8 -*-
+import sys
+import json
+from typing import Any, Dict, List
+
+# =====================================================================================
+# ⚠️ Важно: Этот код сгенерирован автоматически.
+#    Внесите свои изменения в секцию "Реализация функций"
+# =====================================================================================
+
+# =====================================================================================
+# Секция: Импорты
+# =====================================================================================
+${imports}
+
+
+# =====================================================================================
+# Секция: Реализация функций
+# =====================================================================================
+# TODO: Добавьте здесь вашу бизнес-логику для каждой функции.
+
+${functionStrings}
+
+
+# =====================================================================================
+# Секция: FastMCP/STDIO Транспорт (Не изменять)
+# =====================================================================================
+
+def _get_function_schema(func) -> Dict[str, Any]:
+    """Генерирует OpenAPI-совместимую схему из докстринга функции."""
+    if not func.__doc__:
+        return {}
+
+    lines = func.__doc__.strip().split('\\n')
+    description = lines[0].strip()
+    
+    properties = {}
+    required = []
+
+    args_section = False
+    for line in lines:
+        line = line.strip()
+        if line.startswith('Args:'):
+            args_section = True
+            continue
+        if line.startswith('Returns:'):
+            args_section = False
+            continue
+        
+        if args_section and ':' in line:
+            # Обработка необязательных параметров, обозначенных (*), например "аргумент (*str*):"
+            is_required = not line.strip().startswith('(')
+            
+            arg_name_part, arg_desc = line.split(':', 1)
+            arg_name = arg_name_part.split('(')[0].strip()
+            
+            # Предполагаем тип из аннотации
+            param_type_hint = func.__annotations__.get(arg_name, 'string')
+            if hasattr(param_type_hint, '__name__'):
+                 param_type_hint = param_type_hint.__name__
+
+            openapi_type = {
+                'str': 'string',
+                'int': 'integer',
+                'float': 'number',
+                'bool': 'boolean',
+                'list': 'array',
+                'dict': 'object'
+            }.get(param_type_hint, 'string')
+
+            properties[arg_name] = {
+                'type': openapi_type,
+                'description': arg_desc.strip()
+            }
+            if is_required:
+                required.append(arg_name)
+    
+    return {
+        "name": func.__name__,
+        "description": description,
+        "parameters": {
+            "type": "object",
+            "properties": properties,
+            "required": required
+        }
+    }
+
+
+def main():
+    """Главная функция для обработки stdio."""
+    functions = {
+        ${def.functions.map(f => `"${f.name}": ${f.name}`).join(',\n        ')}
+    }
+    
+    if len(sys.argv) > 1 and sys.argv[1] == 'discover':
+        tool_schema = {
+            "name": "${def.name}",
+            "tool_spec": {
+                "function_declarations": [
+                    _get_function_schema(func) for func in functions.values()
+                ]
+            }
+        }
+        print(json.dumps(tool_schema, ensure_ascii=False))
+        return
+
+    for line in sys.stdin:
+        try:
+            call = json.loads(line)
+            function_name = call['function_call']['name']
+            args = call['function_call']['args']
+            
+            if function_name in functions:
+                result = functions[function_name](**args)
+                response = {
+                    "tool_response": {
+                        "name": function_name,
+                        "content": json.dumps(result, ensure_ascii=False)
+                    }
+                }
+                print(json.dumps(response, ensure_ascii=False))
+            else:
+                # Обработка ошибки: функция не найдена
+                error_response = {"tool_response": {"name": function_name, "content": json.dumps({"error": f"Function {function_name} not found."})}}
+                print(json.dumps(error_response, ensure_ascii=False))
+        except (json.JSONDecodeError, KeyError) as e:
+            # Обработка ошибок парсинга или структуры JSON
+            error_response = {"tool_response": {"name": "unknown", "content": json.dumps({"error": f"Invalid input JSON: {e}"})}}
+            print(json.dumps(error_response, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()
+`.trim();
+};
+
+const generateFunctionBody = (def: ToolDefinition, func: FunctionDefinition): string => {
+    // Generate real, working code for the nmap_scanner example
+    if (def.name === 'nmap_scanner') {
+        if (func.name === 'run_scan') {
+            return `
+    try:
+        nm = nmap.PortScanner()
+        # nmap.scan() возвращает результат сканирования
+        scan_result = nm.scan(hosts=targets, ports=ports, arguments=arguments)
+        return scan_result
+    except nmap.PortScannerError as e:
+        return {"error": f"Ошибка сканирования Nmap: {e}. Убедитесь, что nmap установлен и доступен в системном PATH."}
+    except Exception as e:
+        return {"error": f"Произошла непредвиденная ошибка: {e}"}
+`.trim();
+        }
+        if (func.name === 'host_discovery') {
+            return `
+    try:
+        nm = nmap.PortScanner()
+        # Аргумент -sn выполняет "ping scan" для обнаружения хостов без сканирования портов
+        nm.scan(hosts=network_cidr, arguments='-sn')
+        # nm.all_hosts() возвращает список хостов, которые находятся в состоянии 'up'
+        return {"active_hosts": nm.all_hosts()}
+    except nmap.PortScannerError as e:
+        return {"error": f"Ошибка сканирования Nmap: {e}. Убедитесь, что nmap установлен и доступен в системном PATH."}
+    except Exception as e:
+        return {"error": f"Произошла непредвиденная ошибка: {e}"}
+`.trim();
+        }
+    }
+
+    // Default placeholder for other tools
+    const mockReturnValue = () => {
+        switch(func.returnType) {
+            case ParameterType.STRING: return '"Результат выполнен��ёСЏ функции"';
+            case ParameterType.INTEGER: return '123';
+            case ParameterType.FLOAT: return '123.45';
+            case ParameterType.BOOLEAN: return 'True';
+            case ParameterType.LIST: return '["элемент1", "элемент2"]';
+            case ParameterType.DICTIONARY: return '{"ключ": "значение"}';
+            default: return 'None';
+        }
+    };
+
+    return `
+    # TODO: Реализуйте логику функции здесь
+    # Это пример. Замените его своей реализацией.
+    print(f"Функция '${func.name}' вызвана со следующими аргументами:")
+    ${func.parameters.map(p => `    print(f"- ${p.name}: {${p.name}}")`).join('\n')}
+    
+    return ${mockReturnValue()}
+`.trim();
+};
+
+
+const generateFunction = (def: ToolDefinition, func: FunctionDefinition): string => {
+  const paramsString = func.parameters.map(p => {
+    const typeHint = toPythonType(p.type);
+    const defaultValue = p.required ? '' : ' = None';
+    return `${p.name}: ${typeHint}${defaultValue}`;
+  }).join(', ');
+  const returnTypeString = toPythonType(func.returnType);
+
+  const docstringParams = func.parameters.map(p => 
+    `        ${p.name} (${toPythonType(p.type)}): ${p.description}`
+  ).join('\n');
+
+  const docstring = `
+    """${func.description}
+
+    Args:
+${docstringParams || '        Нет.'}
+
+    Returns:
+        ${returnTypeString}: ${func.returnDescription}
+    """
+`.trim();
+
+  const body = generateFunctionBody(def, func);
+
+  return `
+def ${func.name}(${paramsString}) -> ${returnTypeString}:
+    ${docstring}
+    ${body}
+`.trim();
+};
+
+
+const generateSettingsJson = (def: ToolDefinition): string => {
+  return JSON.stringify({
+    servers: [
+      {
+        name: def.name,
+        command: ['python', 'server.py'],
+        transport: 'stdio',
+        type: def.type
+      }
+    ]
+  }, null, 2);
+};
+
+const generateGeminiMd = (def: ToolDefinition): string => {
+  const functionDocs = def.functions.map(func => {
+    const paramsList = func.parameters.map(p => `- \`${p.name}\` (*${toPythonType(p.type)}*): ${p.description}${p.required ? ' (обязательный)' : ''}`).join('\n');
+    return `
+### \`${def.name}:${func.name}\`
+
+${func.description}
+
+**Параметры:**
+${paramsList || 'Нет параметров.'}
+
+**Возвращает:**
+*${toPythonType(func.returnType)}* - ${func.returnDescription}
+`.trim();
+  }).join('\n\n---\n\n');
+
+  const nmapExamples = `
+## Правила и Примеры Использования
+
+**ВАЖНО:** Всегда используй формат \`nmap_scanner:имя_функции()\`.
+
+Если пользователь просит **обнаружить активные устройства в сети**, используй \`host_discovery\`.
+*Запрос пользователя:* "Найди все работающие компьютеры в сети 192.168.0.0/24"
+*Твой вызов:* \`nmap_scanner:host_discovery(network_cidr="192.168.0.0/24")\`
+
+Если пользователь просит **просканировать порты или найти уязвимости**, используй \`run_scan\`.
+*Запрос пользователя:* "Просканируй хост 192.168.1.1 на наличие открытых портов и определи запущенные службы"
+*Твой вызов:* \`nmap_scanner:run_scan(targets="192.168.1.1", ports="1-1024", arguments="-sV")\`
+
+*Запрос пользователя:* "Проведи агрессивное сканирование scanme.nmap.org, чтобы найти возможные векторы ата��и"
+*Твой вызов:* \`nmap_scanner:run_scan(targets="scanme.nmap.org", ports="1-65535", arguments="-A -v")\`
+  `.trim();
+
+  const genericExample = `
+## Пример использования
+
+**Простой вызов:**
+\`\`\`
+${def.name}:${def.functions[0]?.name}(${def.functions[0]?.parameters.filter(p => p.required).map(p => `${p.name}="значение"`).join(', ')})
+\`\`\`
+  `.trim();
+
+  return `
+# Инструкция для Агента: Инструмент "${def.name}"
+
+## Описание
+
+Этот инструмент предоставляет набор утилит для [опишите общую цель инструмента, например: сетевой разведки с помощью Nmap]. Он относится к типу **${def.type}**.
+
+## Функции
+
+${functionDocs}
+
+${def.name === 'nmap_scanner' ? nmapExamples : genericExample}
+`.trim();
+};
+
+const getExampleValue = (param: ParameterDefinition): string => {
+  const { name, type } = param;
+  const lowerParamName = name.toLowerCase();
+
+  if (type === ParameterType.STRING) {
+    if (lowerParamName.includes('target') || lowerParamName.includes('host') || lowerParamName.includes('domain')) return "'scanme.nmap.org'";
+    if (lowerParamName.includes('port')) return "'80,443,8080'";
+    if (lowerParamName.includes('cidr') || lowerParamName.includes('network')) return "'192.168.1.0/24'";
+    if (lowerParamName.includes('argument')) return "'-A -v'";
+    if (lowerParamName.includes('file') || lowerParamName.includes('path')) return "'/path/to/file.txt'";
+    if (lowerParamName.includes('url')) return "'https://example.com'";
+    if (lowerParamName.includes('name')) return "'John Doe'";
+    return "'example_value'";
+  }
+  
+  switch (type) {
+    case ParameterType.INTEGER: return '1024';
+    case ParameterType.FLOAT: return '3.14';
+    case ParameterType.BOOLEAN: return 'True';
+    case ParameterType.LIST: return '["item1", "item2"]';
+    case ParameterType.DICTIONARY: return '{"key": "value"}';
+    default: return 'None';
+  }
+};
+
+const getNaturalLanguageExample = (defName: string, func: FunctionDefinition): string => {
+    if (defName === 'nmap_scanner') {
+        if (func.name === 'run_scan') {
+            return '> "Просканируй scanme.nmap.org, чтобы найти возможные векторы атаки."';
+        }
+        if (func.name === 'host_discovery') {
+            return '> "Найди все активные устройства в моей локальной сети 192.168.1.0/24."';
+        }
+    }
+    return `> "Выполни функцию ${func.name} с тестовыми параметрами."`;
+}
+
+
+const generateExamplesMd = (def: ToolDefinition): string => {
+  if (!def.functions || def.functions.length === 0) {
+    return '# Примеры использования\n\nИнструмент не содержит функций для генерации примеров.';
+  }
+
+  const exampleSnippets = def.functions.map(func => {
+    const paramsString = func.parameters
+      .map(p => `${p.name}=${getExampleValue(p)}`)
+      .join(', ');
+
+    const exampleCall = `${def.name}:${func.name}(${paramsString})`;
+    const naturalLanguageQuery = getNaturalLanguageExample(def.name, func);
+
+    return `
+### Функция: \`${func.name}\`
+
+${func.description}
+
+**Пример запроса на естественном языке:**
+${naturalLanguageQuery}
+
+**В ответ Gemini CLI сгенерирует следующий вызов:**
+\`\`\`bash
+${exampleCall}
+\`\`\`
+    `.trim();
+  }).join('\n\n---\n\n');
+
+  return `
+# Примеры использования для инструмента "${def.name}"
+
+Gemini CLI понимает естественный язык. Он анализирует ваш запрос и вызывает соответствующую функцию инструмента. Ниже показано, как ваши запросы преобразуются в конкретные вызовы.
+
+---
+
+${exampleSnippets}
+  `.trim();
+};
+
+
+export const generateAllCode = (def: ToolDefinition): GeneratedCode => {
+  return {
+    setupPy: generateSetupPy(def),
+    serverPy: generateServerPy(def),
+    settingsJson: generateSettingsJson(def),
+    geminiMd: generateGeminiMd(def),
+    examplesMd: generateExamplesMd(def),
+  };
+};
+
+
+

FastMCPToolGenerator/style.css

@@ -0,0 +1,28 @@
+body {
+	padding: 2rem;
+	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
+}
+
+h1 {
+	font-size: 16px;
+	margin-top: 0;
+}
+
+p {
+	color: rgb(107, 114, 128);
+	font-size: 15px;
+	margin-bottom: 10px;
+	margin-top: 5px;
+}
+
+.card {
+	max-width: 620px;
+	margin: 0 auto;
+	padding: 16px;
+	border: 1px solid lightgray;
+	border-radius: 16px;
+}
+
+.card p:last-child {
+	margin-bottom: 0;
+}

FastMCPToolGenerator/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "module": "ESNext",
+    "lib": [
+      "ES2022",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "skipLibCheck": true,
+    "types": [
+      "node"
+    ],
+    "moduleResolution": "bundler",
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "allowJs": true,
+    "jsx": "react-jsx",
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    },
+    "allowImportingTsExtensions": true,
+    "noEmit": true
+  }
+}
+
+
+

FastMCPToolGenerator/types.ts

@@ -0,0 +1,72 @@
+
+export enum ToolType {
+  REST_API = 'REST_API',
+  CLI = 'CLI',
+  DATABASE = 'DATABASE',
+  CUSTOM = 'CUSTOM',
+  UTILITY = 'UTILITY',
+  CALCULATOR = 'CALCULATOR',
+  CONVERTER = 'CONVERTER'
+}
+
+export enum ParameterType {
+  STRING = 'str',
+  INTEGER = 'int',
+  FLOAT = 'float',
+  BOOLEAN = 'bool',
+  LIST = 'list',
+  DICTIONARY = 'dict'
+}
+
+export interface ParameterDefinition {
+  id: string;
+  name: string;
+  type: ParameterType;
+  description: string;
+  required: boolean;
+}
+
+export interface FunctionDefinition {
+  id: string;
+  name: string;
+  description: string;
+  parameters: ParameterDefinition[];
+  returnType: ParameterType;
+  returnDescription: string;
+}
+
+export interface ToolDefinition {
+  name: string;
+  type: ToolType;
+  dependencies: string;
+  functions: FunctionDefinition[];
+}
+
+export interface GeneratedCode {
+  setupPy: string;
+  serverPy: string;
+  settingsJson: string;
+  geminiMd: string;
+  examplesMd: string;
+}
+
+// Экспортируем для использования в AI промпте
+export const initialFunctionForPrompt: Omit<FunctionDefinition, 'id'> = {
+  name: 'example_function',
+  description: 'Краткое описание того, что делает эта функция.',
+  parameters: [
+    {
+      id: 'param-id-1', // id здесь для примера, в реальности он генерируется
+      name: 'example_param',
+      type: ParameterType.STRING,
+      description: 'Описание параметра.',
+      required: true,
+    },
+  ],
+  returnType: ParameterType.STRING,
+  returnDescription: 'Описание возвращаемого значения.',
+};
+
+
+
+

FastMCPToolGenerator/vite.config.ts

@@ -0,0 +1,72 @@
+import path from 'path';
+
+import { defineConfig, loadEnv } from 'vite';
+
+import react from '@vitejs/plugin-react';
+
+
+
+export default defineConfig(({ mode }) => {
+
+    const env = loadEnv(mode, '.', '');
+
+    
+
+    // Порт для FastAPI (бэкенда) при локальной разработке
+
+    const PYTHON_BACKEND_PORT = 8000;
+
+
+
+    return {
+
+      server: {
+
+        // Используем порт 3000 для Vite (фронтенда)
+
+        port: 3000,
+
+        host: '0.0.0.0',
+
+        proxy: {
+
+          // Перенаправляем все /api запросы на наш Python бэкенд
+
+          '/api': {
+
+            target: `http://127.0.0.1:${PYTHON_BACKEND_PORT}`, // ИСПРАВЛЕНО
+
+            changeOrigin: true,
+
+            secure: false,
+
+          }
+
+        }
+
+      },
+
+      plugins: [react()],
+
+      define: {
+
+        // Ключ API БОЛЬШЕ НЕ НУЖЕН в define!
+
+      },
+
+      resolve: {
+
+        alias: {
+
+          '@': path.resolve(__dirname, '.'),
+
+        }
+
+      }
+
+    };
+
+});
+
+
+

README.md

@@ -1,10 +1,20 @@
----
-title: FastMCPToolGenerator
-emoji: 🐢
-colorFrom: purple
-colorTo: green
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div align="center">
+<img width="1200" height="475" alt="GHBanner" src="https://github.com/user-attachments/assets/0aa67016-6eaf-458a-adb2-6e31a0763ed6" />
+</div>
+
+# Run and deploy your AI Studio app
+
+This contains everything you need to run your app locally.
+
+View your app in AI Studio: https://ai.studio/apps/drive/1DWLDNsbZ8bO_lQPzuDVQB3cpW92HgYCC
+
+## Run Locally
+
+**Prerequisites:**  Node.js
+
+
+1. Install dependencies:
+   `npm install`
+2. Set the `GEMINI_API_KEY` in [.env.local](.env.local) to your Gemini API key
+3. Run the app:
+   `npm run dev`