pvharmo2/gha-lab-e8902eccd3सुरक्षा अनुसंधान प्रयोगशाला: CVE-2025-52467 (pgai pull_request_target वर्कफ़्लो कोड निष्पादन / GITHUB_TOKEN बहिर्गमन) का पुनरुत्पादन — timescale/pgai का स्नैपशॉट
स्वचालित शोध आर्टिफैक्ट — अपस्ट्रीम प्रोजेक्ट नहीं।
यह रिपॉजिटरी Université Laval में मास्टर थीसिस के लिए एक स्वचालित हार्नेस द्वारा निर्मित एक डिस्पोजेबल लैब है, जो प्रकाशित GitHub Actions वर्कफ़्लो कमजोरियों को पुन: प्रस्तुत करने पर केंद्रित है। यह कमिट
2a209b058c60823b57e8b7775b10244ff340eb8b(2025-05-14) परtimescale/pgaiका एक शब्दशः स्नैपशॉट है, जिसे उस प्रोजेक्ट के अपने लाइसेंस के तहत पुनर्वितरित किया गया है, जिसकी फ़ाइल इस स्नैपशॉट में अपरिवर्तित शामिल है।अपस्ट्रीम प्रोजेक्ट शामिल नहीं है, उसे कभी लक्षित नहीं किया जाता है, और यहाँ अध्ययन की गई कमजोरी पहले से ही सार्वजनिक है। इस रिपॉजिटरी में हर सीक्रेट और वेरिएबल एक यादृच्छिक रूप से उत्पन्न डमी मान है — कोई वास्तविक क्रेडेंशियल मौजूद नहीं है। एक्शन संदर्भ और रनर इमेज उसी पर पिन किए गए हैं जो 2025-05-14 को हल हुए थे; स्नैपशॉट में किए गए हर बदलाव के लिए हार्नेस आउटपुट में
pinning.mdदेखें।प्रश्न या आपत्तियाँ: [email protected]
एक Python लाइब्रेरी जो PostgreSQL को RAG और Agentic अनुप्रयोगों के लिए एक मजबूत, प्रोडक्शन-तैयार रिट्रीवल इंजन में बदल देती है।
🔄 PostgreSQL डेटा और S3 दस्तावेज़ों से वेक्टर एम्बेडिंग स्वचालित रूप से बनाएँ और सिंक करें। डेटा बदलते ही एम्बेडिंग स्वचालित रूप से अपडेट हो जाती हैं।
🔍 pgvector और pgvectorscale के साथ शक्तिशाली वेक्टर और सिमेंटिक खोज।
🛡️ बॉक्स से बाहर प्रोडक्शन-तैयार: कुशल एम्बेडिंग जनरेशन के लिए बैच प्रोसेसिंग का समर्थन करता है, जिसमें मॉडल विफलताओं, रेट सीमाओं और लेटेंसी स्पाइक्स के लिए अंतर्निहित हैंडलिंग शामिल है।
🐘 किसी भी PostgreSQL डेटाबेस के साथ काम करता है, जिसमें Timescale Cloud, Amazon RDS, Supabase और अन्य शामिल हैं।
मूल आर्किटेक्चर: सिस्टम में आपके द्वारा लिखा गया एक एप्लिकेशन, एक PostgreSQL डेटाबेस और स्टेटलेस वेक्टराइज़र वर्कर शामिल हैं। एप्लिकेशन PostgreSQL या S3 जैसे स्रोतों से डेटा एम्बेड करने के लिए एक वेक्टराइज़र कॉन्फ़िगरेशन परिभाषित करता है। वर्कर इस कॉन्फ़िगरेशन को पढ़ते हैं, डेटा कतार को एम्बेडिंग और चंक्ड टेक्स्ट में प्रोसेस करते हैं, और परिणाम वापस लिखते हैं। फिर एप्लिकेशन RAG और सिमेंटिक खोज को सशक्त बनाने के लिए इस डेटा को क्वेरी करता है।
इस आर्किटेक्चर की मुख्य ताकत इसकी लचीलापन में निहित है: एप्लिकेशन द्वारा किए गए डेटा संशोधन एम्बेडिंग प्रक्रिया से अलग किए जाते हैं, यह सुनिश्चित करते हुए कि एम्बेडिंग सेवा में विफलताएँ मुख्य डेटा संचालन को प्रभावित नहीं करती हैं।
सबसे पहले, pgai पैकेज इंस्टॉल करें।``` pip install pgai
फिर, pgai डेटाबेस घटकों को इंस्टॉल करें। आप इसे टर्मिनल से CLI का उपयोग करके या अपने Python एप्लिकेशन कोड में pgai python पैकेज का उपयोग करके कर सकते हैं।```
# from the cli
pgai install -d <database-url>
# or from the python package, often done as part of your application setup
import pgai
pgai.install(DB_URL)
यह त्वरित आरंभ प्रदर्शित करता है कि कैसे pgai Vectorizer डेटा बदलने पर एम्बेडिंग्स को स्वचालित रूप से बनाकर और सिंक करके PostgreSQL डेटा पर सिमेंटिक खोज और RAG को सक्षम करता है।
pgai Vectorizer की मुख्य "गुप्त विशेषता" एम्बेडिंग जनरेशन के लिए इसका घोषणात्मक (declarative) दृष्टिकोण है। बस अपनी पाइपलाइन परिभाषित करें और Vectorizer को एम्बेडिंग्स को सिंक में रखने की परिचालन जटिलता संभालने दें, तब भी जब एम्बेडिंग एंडपॉइंट अविश्वसनीय हों। आप पाइपलाइन का एक सरल संस्करण निम्नानुसार परिभाषित कर सकते हैं:```sql CREATE TABLE IF NOT EXISTS wiki ( id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY, url TEXT NOT NULL, title TEXT NOT NULL, text TEXT NOT NULL )
SELECT ai.create_vectorizer( 'wiki'::regclass, loading => ai.loading_column(column_name=>'text'), destination => ai.destination_table(target_table=>'wiki_embedding_storage'), embedding => ai.embedding_openai(model=>'text-embedding-ada-002', dimensions=>'1536') )
वेक्टराइज़र स्वचालित रूप से `wiki` टेबल की सभी पंक्तियों के लिए एम्बेडिंग बनाएगा, और, अधिक महत्वपूर्ण बात, अंतर्निहित डेटा में बदलाव होने पर एम्बेडिंग को उसके साथ सिंक में रखेगा। **इसे लगभग `wiki` टेबल पर एक इंडेक्स घोषित करने जैसा समझें**, लेकिन डेटाबेस के आपके लिए इंडेक्स डेटास्ट्रक्चर को प्रबंधित करने के बजाय, Vectorizer एम्बेडिंग का प्रबंधन कर रहा है।
## क्विक स्टार्ट चलाना
**पूर्वापेक्षाएँ:**
- एक PostgreSQL डेटाबेस ([डॉकर निर्देश](https://docs.timescale.com/self-hosted/latest/install/installation-docker/))।
- एक OpenAI API कुंजी (हम क्विक स्टार्ट में एम्बेडिंग के लिए openai का उपयोग करते हैं, लेकिन आप [कई प्रदाताओं](#supported-embedding-models) का उपयोग कर सकते हैं)।
निम्नलिखित के साथ एक `.env` फ़ाइल बनाएँ:```
OPENAI_API_KEY=<your-openai-api-key>
DB_URL=<your-database-url>
आप क्विकस्टार्ट उदाहरण से पूरा python कोड और requirements.txt डाउनलोड कर सकते हैं और इसे .env फ़ाइल के समान निर्देशिका में चला सकते हैं।
Pgai को डेटाबेस में कुछ कैटलॉग टेबल और फ़ंक्शन स्थापित करने की आवश्यकता होती है। यह pgai.install फ़ंक्शन का उपयोग करके किया जाता है, जो डेटाबेस के ai स्कीमा में आवश्यक घटकों को स्थापित करेगा।```python
pgai.install(DB_URL)
### वेक्टराइज़र बनाएं
यह वेक्टराइज़र को परिभाषित करता है, जो सिस्टम को बताता है कि `wiki` टेबल में `text` कॉलम से एम्बेडिंग कैसे बनाई जाए। वेक्टराइज़र एक `wiki_embedding` व्यू बनाता है जिसे हम एम्बेडिंग के लिए क्वेरी कर सकते हैं (जैसा कि हम नीचे देखेंगे)।```python
async def create_vectorizer(conn: psycopg.AsyncConnection):
async with conn.cursor() as cur:
await cur.execute("""
SELECT ai.create_vectorizer(
'wiki'::regclass,
if_not_exists => true,
loading => ai.loading_column(column_name=>'text'),
embedding => ai.embedding_openai(model=>'text-embedding-ada-002', dimensions=>'1536'),
destination => ai.destination_table(view_name=>'wiki_embedding')
)
""")
await conn.commit()
इस उदाहरण में, हम मौजूदा डेटा के लिए एम्बेडिंग बनाने हेतु वेक्टराइज़र वर्कर को एक बार चलाते हैं।```python worker = Worker(DB_URL, once=True) worker.run()
वास्तविक एप्लिकेशन में, हम हर बार embeddings बनाने के लिए worker को इस तरह मैन्युअल रूप से कॉल नहीं करेंगे। इसके बजाय, हम worker को पृष्ठभूमि में चलाएंगे और यह लगातार चलता रहेगा, vectorizer से काम के लिए polling करता रहेगा।
आप worker को एप्लिकेशन, cli, या docker से पृष्ठभूमि में चला सकते हैं। अधिक विवरण के लिए [vectorizer worker](https://github.com/pvharmo2/gha-lab-e8902eccd3/blob/main/docs/vectorizer/worker.md) दस्तावेज़ देखें।
### semantic search का उपयोग करके wiki लेख खोजें
यह PostgreSQL में मानक pgvector semantic search है। खोज `wiki_embedding` view के विरुद्ध की जाती है, जिसे vectorizer द्वारा बनाया गया है और इसमें `wiki` तालिका के सभी कॉलम शामिल हैं, साथ ही `embedding` कॉलम और chunk टेक्स्ट भी शामिल है। यह फ़ंक्शन `wiki` तालिका से संपूर्ण `text` कॉलम और टेक्स्ट के छोटे chunks दोनों लौटाता है जो क्वेरी के लिए सबसे अधिक प्रासंगिक हैं।```python
@dataclass
class WikiSearchResult:
id: int
url: str
title: str
text: str
chunk: str
distance: float
async def _find_relevant_chunks(client: AsyncOpenAI, query: str, limit: int = 1) -> List[WikiSearchResult]:
# Generate embedding for the query using OpenAI's API
response = await client.embeddings.create(
model="text-embedding-ada-002",
input=query,
encoding_format="float",
)
embedding = np.array(response.data[0].embedding)
# Query the database for the most similar chunks using pgvector's cosine distance operator (<=>)
async with pool.connection() as conn:
async with conn.cursor(row_factory=class_row(WikiSearchResult)) as cur:
await cur.execute("""
SELECT w.id, w.url, w.title, w.text, w.chunk, w.embedding <=> %s as distance
FROM wiki_embedding w
ORDER BY distance
LIMIT %s
""", (embedding, limit))
return await cur.fetchall()
यह कोड इस बात के लिए उल्लेखनीय है कि यह क्या नहीं कर रहा है। यह wiki तालिका में एक नए लेख का एक सरल इंसर्ट है। एम्बेडिंग बनाने के लिए हमें कुछ अलग करने की आवश्यकता नहीं थी, वेक्टराइज़र वर्कर डेटा बदलने पर एम्बेडिंग को अपडेट करने का ध्यान रखेगा।```python
def insert_article_about_pgai(conn: psycopg.AsyncConnection):
async with conn.cursor(row_factory=class_row(WikiSearchResult)) as cur:
await cur.execute("""
INSERT INTO wiki (url, title, text) VALUES
('https://en.wikipedia.org/wiki/pgai', 'pgai', 'pgai is a Python library that turns PostgreSQL into the retrieval engine behind robust, production-ready RAG and Agentic applications. It does this by automatically creating vector embeddings for your data based on the vectorizer you define.')
""")
await conn.commit()
### LLM के साथ RAG करें
यह कोड LLM के साथ RAG करता है। यह ऊपर परिभाषित `_find_relevant_chunks` फ़ंक्शन का उपयोग करके `wiki` तालिका से पाठ के सबसे प्रासंगिक हिस्सों (chunks) को खोजता है और फिर प्रतिक्रिया उत्पन्न करने के लिए LLM का उपयोग करता है।```python
query = "What is the main thing pgai does right now?"
relevant_chunks = await _find_relevant_chunks(client, query)
context = "\n\n".join(
f"{chunk.title}:\n{chunk.text}"
for chunk in relevant_chunks
)
prompt = f"""Question: {query}
Please use the following context to provide an accurate response:
{context}
Answer:"""
response = await client.chat.completions.create({
model: "gpt-3.5-turbo",
messages: [{ role: "user", content: prompt }],
})
print("RAG response:")
print(response.choices[0].message.content)
अन्य क्विकस्टार्ट देखें:
वेक्टराइज़र के बारे में और अधिक जानें:
हमारी pgai Python लाइब्रेरी आपको अपने डेटा से उत्पन्न एम्बेडिंग के साथ काम करने देती है:
आप वेक्टर एम्बेडिंग का उपयोग कर सकते हैं:
हम एक PostgreSQL एक्सटेंशन भी प्रदान करते हैं जो सीधे SQL से LLM मॉडल कॉलिंग कर सकता है। यह अक्सर आपके मौजूदा डेटा पर वर्गीकरण, सारांशीकरण और डेटा संवर्धन जैसे उपयोग मामलों के लिए उपयोगी होता है।
वेक्टराइज़र को लचीला और अनुकूलन योग्य बनाने के लिए डिज़ाइन किया गया है। प्रत्येक वेक्टराइज़र आपके डेटा से एम्बेडिंग बनाने के लिए एक पाइपलाइन परिभाषित करता है। पाइपलाइन घटकों की एक श्रृंखला द्वारा परिभाषित की जाती है जो डेटा पर क्रमिक रूप से लागू होते हैं:
एम्बेडिंग के लिए निम्नलिखित मॉडल समर्थित हैं:
वेक्टर एम्बेडिंग बनाना सरल और सीधा है। चुनौती यह है कि LLM कुछ हद तक अविश्वसनीय हैं और एंडपॉइंट रुक-रुक कर विफलताएँ और/या घटा हुआ प्रदर्शन प्रदर्शित करते हैं। विफलताओं को ठीक से संभालने का एक महत्वपूर्ण हिस्सा यह है कि आपके प्राथमिक डेटा-संशोधन ऑपरेशन (INSERT, UPDATE, DELETE) एम्बेडिंग ऑपरेशन पर निर्भर नहीं होने चाहिए। अन्यथा, आपका एप्लिकेशन हर बार एंडपॉइंट धीमा होने या विफल होने पर डाउन हो जाएगा और आपका उपयोगकर्ता अनुभव प्रभावित होगा।
सामान्यतः, एंडपॉइंट विफलताओं को ठीक से संभालने के लिए आपको एक कस्टम MLops पाइपलाइन लागू करने की आवश्यकता होगी। इसमें आमतौर पर Kafka जैसी कतार प्रणाली, विशेष वर्कर और कतार को संभालने और विफल अनुरोधों को पुनः प्रयास करने के लिए अन्य बुनियादी ढाँचा शामिल होता है। यह बहुत काम है और इसमें गलती करना आसान है।
pgai के साथ, आप यह सब छोड़ सकते हैं और अपने एप्लिकेशन को बनाने पर ध्यान केंद्रित कर सकते हैं क्योंकि वेक्टराइज़र आपके लिए एम्बेडिंग प्रबंधित कर रहा है। हमने विभिन्न विफलता मोडों को संभालने के लिए कतारबद्ध और पुनः प्रयास तर्क बनाया है जिनका आप सामना कर सकते हैं। क्योंकि हम यह काम पृष्ठभूमि में करते हैं, प्राथमिक डेटा संशोधन ऑपरेशन एम्बेडिंग ऑपरेशन पर निर्भर नहीं होते हैं। यही कारण है कि pgai बॉक्स से बाहर प्रोडक्शन-रेडी है।
कई विशेष वेक्टर डेटाबेस आपके लिए एम्बेडिंग बनाते हैं। हालाँकि, वे आमतौर पर तब विफल हो जाते हैं जब एम्बेडिंग एंडपॉइंट डाउन या घटे हुए होते हैं, जिससे त्रुटि प्रबंधन और पुनः प्रयास का बोझ आप पर वापस आ जाता है।
हम pgai में योगदान का स्वागत करते हैं! अधिक जानकारी के लिए योगदान पृष्ठ देखें।
pgai अभी भी प्रारंभिक चरण में है। इस परियोजना की दिशा को आकार देने में मदद करने का यह एक अच्छा समय है; हम वर्तमान में प्राथमिकताएँ तय कर रहे हैं। सुविधाओं की सूची पर एक नज़र डालें जिन पर हम काम करने के बारे में सोच रहे हैं। बेझिझक टिप्पणी करें, सूची का विस्तार करें, या चर्चा फ़ोरम पर जाएँ।
शुरू करने के लिए, योगदान कैसे करें और dev/test वातावरण कैसे सेट करें देखें।
Timescale एक PostgreSQL डेटाबेस कंपनी है। अधिक जानने के लिए timescale.com पर जाएँ।
Timescale Cloud एक उच्च-प्रदर्शन, डेवलपर-केंद्रित, क्लाउड प्लेटफ़ॉर्म है जो सबसे अधिक मांग वाले AI, टाइम-सीरीज़, एनालिटिक्स और इवेंट वर्कलोड के लिए PostgreSQL सेवाएँ प्रदान करता है। Timescale Cloud प्रोडक्शन एप्लिकेशन के लिए आदर्श है और उच्च उपलब्धता, स्ट्रीमिंग बैकअप, समय के साथ अपग्रेड, भूमिकाएँ और अनुमतियाँ, और बेहतरीन सुरक्षा प्रदान करता है।