OPENAI_API_KEY=tu_clave_de_api_de_openai
OPENAI_ASSISTANT_ID=tu_id_de_asistente_de_openai
VECTOR_STORE_ID=tu_id_de_vector_store

{
  "name": "process_uploaded_markdown",
  "description": "Parse a Markdown file uploaded to OpenAI, extract key information, and structure the URL with a base URL.",
  "strict": true,
  "parameters": {
    "type": "object",
    "properties": {
      "file_id": {
        "type": "string",
        "description": "The ID of the Markdown file uploaded to OpenAI."
      },
      "base_url": {
        "type": "string",
        "description": "The base URL to construct the full URL for the post."
      }
    },
    "required": [
      "file_id",
      "base_url"
    ],
    "additionalProperties": false
  }
}

import { enableCors } from "@/src/middleware/enableCors";
import { methodValidator } from "@/src/utils/methodValidator";
import OpenAI from "openai";

const API_KEY = process.env.OPENAI_API_KEY;
const ASSISTANT_ID = process.env.OPENAI_ASSISTANT_ID;

async function assistantHandler(req, res) {
  console.log(`Recibida solicitud ${req.method} en /api/assistant`);

  await methodValidator(req, res, 'POST');

  if (res.headersSent) {
    return;
  }

  const openai = new OpenAI({
    apiKey: API_KEY,
    headers: {
      'OpenAI-Beta': 'assistants=v2',
    }
  });

  try {
    const { prompt, threadId, fileId } = req.body;

    if (!prompt) {
      res.status(400).json({ error: "Falta el parámetro 'prompt' en la solicitud." });
      return;
    }

    let thread;

    if (!threadId) {
      thread = await openai.beta.threads.create();
      console.log("Nuevo thread creado:", thread.id);
    } else {
      thread = { id: threadId };
      console.log("Usando thread existente:", thread.id);
    }

    if (fileId) {
      const base_url = "https://danieljsaldana.dev";

      const functionCall = await openai.chat.completions.create({
        model: 'gpt-4',
        messages: [{ role: 'system', content: 'Extract relevant information from the markdown file.' }],
        functions: [
          {
            name: 'process_uploaded_markdown',
            description: 'Parse and extract key information from a Markdown file.',
            parameters: {
              type: 'object',
              properties: {
                file_id: { type: 'string', description: 'The ID of the Markdown file.' },
                base_url: { type: 'string', description: 'The base URL to construct the full URL.' }
              },
              required: ['file_id', 'base_url']
            }
          }
        ],
        function_call: {
          name: 'process_uploaded_markdown',
          arguments: JSON.stringify({ file_id: fileId, base_url })
        }
      });

      const processedData = JSON.parse(functionCall.choices[0].message.function_call.arguments);

      let content = `He procesado el archivo Markdown. Aquí está la información relevante:\n\nTítulo: ${processedData.title}\nDescripción: ${processedData.description}\nFecha: ${processedData.date}\nURL: ${processedData.url}\nTags: ${processedData.tags}\nCategorías: ${processedData.categories}`;

      content = content.replace(/【\d+:\d+†source】/g, '');

      await openai.beta.threads.messages.create(thread.id, {
        role: "assistant",
        content: content,
      });
    } else {
      await openai.beta.threads.messages.create(thread.id, {
        role: "user",
        content: prompt,
      });
    }

    let completeResponse = '';

    const run = await openai.beta.threads.runs.stream(thread.id, {
      assistant_id: ASSISTANT_ID,
    });

    run.on('textDelta', (textDelta) => {
      if (textDelta && typeof textDelta.value === 'string') {
        completeResponse += textDelta.value;
      }
    });

    run.on('end', () => {
      completeResponse = completeResponse.replace(/【\d+:\d+†source】/g, '');

      res.writeHead(200, { "Content-Type": "text/plain" });
      res.end(completeResponse);
    });

    run.on('error', (error) => {
      console.error('Error en el streaming:', error.message);
      res.status(500).json({ error: 'Error en el streaming de la respuesta' });
    });

  } catch (error) {
    console.error('Error al llamar a la API de OpenAI:', error.message);
    res.status(500).json({ error: 'Error al procesar la solicitud' });
  }
}

export default enableCors(assistantHandler);

const fs = require('fs');
const path = require('path');
const OpenAI = require('openai');
require('dotenv').config();

const VECTOR_STORE_ID = process.env.VECTOR_STORE_ID;
const POSTS_DIRECTORY = path.join(__dirname, '..', 'src', 'content', 'posts');
const OUTPUT_DIRECTORY = path.join(__dirname, '..', 'src', 'output');

if (!fs.existsSync(OUTPUT_DIRECTORY)) {
  fs.mkdirSync(OUTPUT_DIRECTORY, { recursive: true

 });
}

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const fileExistsInVectorStore = async (fileName) => {
  try {
    const response = await openai.beta.vectorStores.files.list(VECTOR_STORE_ID);
    const files = response.data?.files || [];

    return files.some(file => file.file_name === fileName);
  } catch (error) {
    console.error('Error al listar archivos en el vector store:', error);
    return false;
  }
};

const uploadFilesToVectorStore = async () => {
  try {
    const posts = fs.readdirSync(POSTS_DIRECTORY);
    const allowedExtensions = ['.txt', '.md', '.pdf'];

    for (const post of posts) {
      const postPath = path.join(POSTS_DIRECTORY, post);
      const postExtension = path.extname(post);

      if (allowedExtensions.includes(postExtension)) {
        const exists = await fileExistsInVectorStore(post);

        if (exists) {
          console.log(`Archivo ${post} ya existe en el vector store, se omite la subida.`);
        } else {
          const uploadedFile = await openai.files.create({
            file: fs.createReadStream(postPath),
            purpose: 'assistants',
          });

          console.log(`Archivo subido: ${post} con ID: ${uploadedFile.id}`);

          await openai.beta.vectorStores.files.createAndPoll(VECTOR_STORE_ID, {
            file_id: uploadedFile.id
          });
          console.log(`Archivo ${post} agregado al vector store ${VECTOR_STORE_ID}`);
        }
      } else {
        console.log(`Archivo ${post} ignorado (extensión no permitida)`);
      }
    }
  } catch (error) {
    console.error('Error al subir archivos al vector store:', error);
  }
};

uploadFilesToVectorStore();