मास्ट्रा और अपस्टैश के साथ एक एआई आर्टिकल रिसर्च असिस्टेंट बनाएं

एआई अनुसंधान एजेंटों का परिचय

1. शोधकर्ता के प्राकृतिक-भाषा प्रश्न को समझता है
2. arXiv सार के वेक्टर डेटाबेस में सबसे अधिक प्रासंगिक कागजात ढूँढता है
3. मुख्य जानकारियों का सारांश देता है और बताता है कि वे प्रश्न का उत्तर कैसे देते हैं
4. गहराई से पढ़ने के लिए एक सीधा पीडीएफ लिंक प्रदान करता है

मस्त्रा क्या है?

• एजेंट और वर्कफ़्लो - एजेंट, टूल और मल्टी-स्टेप वर्कफ़्लोज़ लिखें
• पुनर्प्राप्ति-संवर्धित पीढ़ी (आरएजी) - अंतर्निहित मेमोरी और वेक्टर स्टोर
• मल्टी-एलएलएम - OpenAI, क्लाउड और अन्य के साथ काम करता है।

परियोजना के लिए तकनीकी स्टैक

• मस्ट्रा फ्रेमवर्क एआई एजेंट और टूल बनाने के लिए
• अपस्टैश रेडिस एजेंट को बातचीत की स्मृति देने के लिए
• अपस्टैश वेक्टर अनुसंधान लेख सार के एम्बेडिंग को संग्रहीत करने के लिए
• Next.js और Vercel वेब एप्लिकेशन बनाने और तैनात करने के लिए

कार्यान्वयन पूर्वाभ्यास

मस्ट्रा प्रोजेक्ट बनाना

npm create mastra@latest

एजेंट और टूल बनाना

export const articleAgent = new Agent({
 name: "articleAgent",
 instructions: instruction,
 model: openai('gpt-4o'),
 tools: { articleQueryTool },
 memory: memory
});

एजेंट की मेमोरी

export const memory = new Memory({
 storage: myUpstashStore,
 options: {
 lastMessages: 10,
 semanticRecall: false,
 threads: {
 generateTitle: true
 }
 }
});

export const myUpstashStore = new UpstashStore({
 url: process.env.UPSTASH_REDIS_REST_URL!,
 token: process.env.UPSTASH_REDIS_REST_TOKEN!,
});

export const myUpstashVector = new UpstashVector({
 url: process.env.UPSTASH_VECTOR_REST_URL!,
 token: process.env.UPSTASH_VECTOR_REST_TOKEN!,
});
 
export const memory = new Memory({
 storage: myUpstashStore,
 vector: myUpstashVector,
 embedder: openai.embedding("text-embedding-3-small"),
 options: {
 lastMessages: 10,
 semanticRecall: {
 topK: 3,
 messageRange: 2,
 scope: 'resource'
 },
 threads: {
 generateTitle: true
 }
 }
});

उपकरण

export const articleQueryTool = createTool({
 id: 'get-relevant-article',
 description: 'Get relevant article information',
 inputSchema: z.object({
 question: z.string().describe('the question about the field'),
 }),
 outputSchema: z.object({
 bestOption: z.object({
 abstract: z.string().describe('the abstract of the article'),
 title: z.string().describe('the title of the article'),
 pdfUrl: z.string().describe('the PDF URL of the article')
 })
 }),
 execute: async ({ context }) => {
 return await querySimilar(context.question);
 },
 });

const querySimilar = async (query: string) => {
 
 const { embedding } = await embed({
 value: query,
 model: openai.embedding("text-embedding-3-small"),
 });
 
 const results = await myMastraUpstashVector.query({
 indexName: "arxiv",
 queryVector: embedding,
 topK: 3,
 });
 
 if (results && results.length > 0) {
 const bestMatch = results[0];
 const metadata = bestMatch.metadata as ArxivPaper;
 
 return {
 bestOption: {
 abstract: metadata.abstract,
 title: metadata.title,
 pdfUrl: metadata.pdfUrl
 }
 };
 }
 throw new Error("No relevant information found");
}

द मस्त्रा इंस्टेंस

export const mastra = new Mastra({
 storage: myMastraUpstashStore,
 agents: { articleAgent },
 deployer: new VercelDeployer()
});

.
└── mastra
 ├── agents
 │ └── index.ts
 ├── tools
 │ └── index.ts
 └── index.ts
 

OPENAI_API_KEY=
 
UPSTASH_VECTOR_REST_URL=
UPSTASH_VECTOR_REST_TOKEN=
 
UPSTASH_REDIS_REST_URL=
UPSTASH_REDIS_REST_TOKEN=

npm run build && vercel --prod

npm run dev

Next.js सर्वर

npm install @mastra/client-js@latest

import { MastraClient } from "@mastra/client-js";
 
export const mastra_sdk = new MastraClient({
 baseUrl: process.env.NEXT_PUBLIC_MASTRA_API!,
 retries: 3,
 });

export const mastra = new Mastra({
 storage: myMastraUpstashStore,
 agents: { articleAgent },
 server: {
 port: 4111, 
 timeout: 10000, 
 }
});

export const MASTRA_CONFIG = {
 resourceId: process.env.NEXT_PUBLIC_RESOURCE_ID || "articleAgent",
 agentId: "articleAgent", 
 baseUrl: process.env.NEXT_PUBLIC_MASTRA_API || "http://localhost:4111",
 retries: 3,
}; // this is exported in another file so that we can use it anywhere in the codebase.
 
// Get your agent and simply stream your response through your agent object.
const agent = mastra_sdk.getAgent(MASTRA_CONFIG.agentId);
 
const response = await agent.stream({
 messages: [message],
 resourceId: MASTRA_CONFIG.resourceId,
 threadId: threadId
});

import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';
 
// Using the same Redis DB across the project 
export const rateLimit = new Ratelimit({
 redis: new Redis({
 url: process.env.UPSTASH_REDIS_MEMORY_URL!,
 token: process.env.UPSTASH_REDIS_MEMORY_TOKEN!
 }),
 limiter: Ratelimit.slidingWindow(10, '10s'),
 prefix: 'upstash-ratelimit',
});
 
 
// Fetch the below function before every stream. 
export async function isRateLimited(id: string): Promise<boolean> {
 const { success } = await rateLimit.limit(id);
 return !success; 
}

const thread = await mastraClient.createMemoryThread({
 title: "New Conversation",
 metadata: { category: "support" },
 resourceId: "resource-1",
 agentId: "agent-1",
});

arXiv लेख

CATEGORIES=cs.AI
RUN_BEGINNING_STACK=false

const categories = process.env.CATEGORIES?.split(',') || []; // Get the desired categories and split them for the query.
const searchQuery = categories.length === 1 ? `cat:${categories[0]}` : `(${categories.map(c => `cat:${c}`).join(" OR ")})`;
const query = `search_query=${searchQuery}&sortBy=submittedDate&sortOrder=descending`;
const url = `http://export.arxiv.org/api/query?${query}`;
const response = await axios.get(url); // Make the API call with the constructed URL.

export interface ArxivPaper {
 id: string;
 title: string;
 abstract: string;
 authors: string[];
 published: string;
 pdfUrl: string;
 category: string;
}// The type for our articles, across our codebase.
 
async function storeAbstracts(papers: ArxivPaper[]) {
 const embeddingModel = openai.embedding("text-embedding-3-small"); // The same model used to query on the Mastra side.
 
 const embeddings = await embedArticles(papers, embeddingModel)
 
 // Put the embeddings into the required form with their metadata.
 const vectorsToUpsert = getVectorsToUpsert(embeddings, papers) 
 
 for (let j = 0; j < vectorsToUpsert.length; j++) { 
 await vectorStore.upsert(vectorsToUpsert[j], { namespace: "arxiv" }); // Upsert the embeddings with their metadata to Upstash Vector.
 }
}

// src/app/api/arxiv_reneval/route.ts
import { verifySignatureAppRouter } from "@upstash/qstash/nextjs"
import { fetchAndUpsertYesterday} from "@/services/arxiv"
 
async function handler(request: Request) {
 console.log("Fetching and upserting yesterday's papers...")
 await fetchAndUpsertYesterday()
 console.log("Fetching and upserting yesterday's papers completed")
 return Response.json({ success: true })
}
 
export const POST = verifySignatureAppRouter(handler)

• उन्हें अपनी स्थानीय मशीन पर क्लोन करें।
• अपना पर्यावरण चर भरें (उदाहरण .env)। फ़ाइलें उपलब्ध कराई गई हैं).
• दोनों प्रोजेक्ट के लिए अलग-अलग टर्मिनल में रूट डायरेक्टरी पर जाएं।
• निम्न आदेश चलाएँ:

npm install
npm run dev