ចង់ឱ្យ AI យល់ច្បាស់អំពីកូដរបស់អ្នកទេ? ឧបករណ៍នេះនិយាយថាវាអាចជួយបាន។

នៅក្នុងប្លុកនេះ យើងនឹងបង្ហាញអ្នកពីរបៀបធ្វើលិបិក្រម codebase សម្រាប់ RAG ជាមួយ CocoIndex។ CocoIndex គឺជាឧបករណ៍មួយដើម្បីជួយអ្នកក្នុងការធ្វើលិបិក្រម និងសាកសួរទិន្នន័យរបស់អ្នក។ វាត្រូវបានរចនាឡើងដើម្បីប្រើជាក្របខណ្ឌក្នុងការសាងសង់បំពង់បង្ហូរទិន្នន័យផ្ទាល់ខ្លួនរបស់អ្នក។ CocoIndex ផ្តល់នូវការគាំទ្រដែលភ្ជាប់មកជាមួយសម្រាប់ការបំបែកកូដមូលដ្ឋាន ដោយមានការគាំទ្រពីអ្នកថែរក្សាដើមឈើដើម។

អ្នកថែរក្សា ដើមឈើ

Tree-sitter គឺជាឧបករណ៍បង្កើតញែក និងបណ្ណាល័យវិភាគបន្ថែម វាមាននៅក្នុង Rust 🦀 - GitHub ។ CocoIndex មានការរួមបញ្ចូល Rust ជាមួយ Tree-sitter ដើម្បីញែកកូដយ៉ាងមានប្រសិទ្ធភាព និងស្រង់ដើមវាក្យសម្ព័ន្ធសម្រាប់ភាសាសរសេរកម្មវិធីផ្សេងៗ។

Codebase chunking គឺ​ជា​ដំណើរ​ការ​នៃ​ការ​បំបែក​មូលដ្ឋាន​កូដ​មួយ​ទៅ​ជា​តូច​ជាង, កំណាត់​ដែល​មាន​ន័យ​ជា​អត្ថន័យ​។ CocoIndex ប្រើប្រាស់សមត្ថភាពរបស់ Tree-sitter ដើម្បីបំបែកកូដដោយឆ្លាតវៃដោយផ្អែកលើរចនាសម្ព័ន្ធវាក្យសម្ព័ន្ធពិតប្រាកដ ជាជាងការបំបែកបន្ទាត់តាមអំពើចិត្ត។ បន្ទាប់​មក​កំណាត់​ដែល​ជាប់​គ្នា​តាម​អត្ថន័យ​ទាំងនេះ​ត្រូវ​បាន​ប្រើ​ដើម្បី​បង្កើត​លិបិក្រម​ដែល​មាន​ប្រសិទ្ធិ​ភាព​កាន់​តែ​ខ្លាំង​សម្រាប់​ប្រព័ន្ធ RAG ដែល​អនុញ្ញាត​ឱ្យ​ការ​ទាញ​យក​កូដ​កាន់​តែ​ច្បាស់​និង​ការ​រក្សា​បរិបទ​កាន់​តែ​ប្រសើរ។

Fast Pass 🚀 - អ្នកអាចស្វែងរកលេខកូដពេញលេញ នៅទីនេះ ។ លេខកូដ Python ត្រឹមតែ 50 បន្ទាត់សម្រាប់ RAG pipeline សូមពិនិត្យមើលវាចេញ 🤗!

សូមផ្តល់ឱ្យ CocoIndex នៅលើ Github នូវផ្កាយមួយដើម្បីគាំទ្រពួកយើងប្រសិនបើអ្នកចូលចិត្តការងាររបស់យើង។ អរគុណច្រើនជាមួយការឱបដូងក្តៅ🥥🤗។

តម្រូវការជាមុន

ប្រសិនបើអ្នកមិនបានដំឡើង Postgres ទេ សូមមើល ការណែនាំអំពីការដំឡើង ។ CocoIndex ប្រើប្រាស់ Postgres ដើម្បីគ្រប់គ្រងលិបិក្រមទិន្នន័យ យើងមានវានៅលើផែនទីបង្ហាញផ្លូវរបស់យើង ដើម្បីគាំទ្រដល់មូលដ្ឋានទិន្នន័យផ្សេងទៀត រួមទាំងទិន្នន័យដែលកំពុងដំណើរការផងដែរ។ ប្រសិនបើអ្នកចាប់អារម្មណ៍លើមូលដ្ឋានទិន្នន័យផ្សេងទៀត សូមប្រាប់ពួកយើងដោយបង្កើត បញ្ហា GitHub ឬ Discord ។

កំណត់ លំហូរ cocoIndex

ចូរកំណត់លំហូរ cocoIndex ដើម្បីអានពី codebase ហើយធ្វើលិបិក្រមវាសម្រាប់ RAG ។

ដ្យាក្រាមលំហូរខាងលើបង្ហាញពីរបៀបដែលយើងនឹងដំណើរការមូលដ្ឋានកូដរបស់យើង៖

1. អានឯកសារកូដពីប្រព័ន្ធឯកសារមូលដ្ឋាន
2. ស្រង់ផ្នែកបន្ថែមឯកសារ
3. បំបែកកូដទៅជាកំណាត់ន័យធៀបដោយប្រើ Tree-sitter
4. បង្កើតការបង្កប់សម្រាប់កំណាត់នីមួយៗ
5. រក្សាទុកក្នុងមូលដ្ឋានទិន្នន័យវ៉ិចទ័រសម្រាប់ការទាញយក

ចូរយើងអនុវត្តលំហូរនេះជាជំហាន ៗ ។

1. បន្ថែម codebase ជាប្រភព .

 @cocoindex.flow_def(name="CodeEmbedding") def code_embedding_flow(flow_builder: cocoindex.FlowBuilder, data_scope: cocoindex.DataScope): """ Define an example flow that embeds files into a vector database. """ data_scope["files"] = flow_builder.add_source( cocoindex.sources.LocalFile(path="../..", included_patterns=["*.py", "*.rs", "*.toml", "*.md", "*.mdx"], excluded_patterns=[".*", "target", "**/node_modules"])) code_embeddings = data_scope.add_collector()

ក្នុងឧទាហរណ៍នេះ យើងនឹងធ្វើលិបិក្រម cocoindex codebase ពី root directory ។ អ្នកអាចផ្លាស់ប្តូរផ្លូវទៅកាន់មូលដ្ឋានកូដដែលអ្នកចង់ធ្វើលិបិក្រម។ យើងនឹងធ្វើលិបិក្រមឯកសារទាំងអស់ជាមួយនឹងផ្នែកបន្ថែមនៃ .py , .rs , .toml , .md , .mdx , និងរំលងថតដែលចាប់ផ្តើមដោយ ., target (នៅក្នុង root) និង node_modules (នៅក្រោមថតណាមួយ)។

flow_builder.add_source នឹងបង្កើតតារាងមួយដែលមានវាលរងខាងក្រោម សូមមើល ឯកសារ នៅទីនេះ។

• filename (key, type: str ) : ឈ្មោះឯកសាររបស់ file ឧ. dir1/file1.md
• content (ប្រភេទ៖ str ប្រសិនបើ binary False បើមិនដូច្នេះទេ bytes ) : ខ្លឹមសារនៃឯកសារ

2. ដំណើរការឯកសារនីមួយៗ ហើយប្រមូលព័ត៌មាន .

2.1 ស្រង់ផ្នែកបន្ថែមនៃឈ្មោះឯកសារ

ដំបូង​យើង​កំណត់​មុខងារ​មួយ​ដើម្បី​ស្រង់​ផ្នែក​បន្ថែម​នៃ​ឈ្មោះ​ឯកសារ​ពេល​ដំណើរការ​ឯកសារ​នីមួយៗ។ អ្នកអាចស្វែងរកឯកសារសម្រាប់មុខងារផ្ទាល់ខ្លួន នៅទីនេះ ។

 @cocoindex.op.function() def extract_extension(filename: str) -> str: """Extract the extension of a filename.""" return os.path.splitext(filename)[1]

បន្ទាប់មកយើងនឹងដំណើរការឯកសារនីមួយៗ ហើយប្រមូលព័ត៌មាន។

 # ... with data_scope["files"].row() as file: file["extension"] = file["filename"].transform(extract_extension)

នៅទីនេះយើងស្រង់ផ្នែកបន្ថែមនៃឈ្មោះឯកសារ ហើយរក្សាទុកវានៅក្នុងវាលផ្នែក extension ។ ឧទាហរណ៍ ប្រសិនបើឈ្មោះឯកសារគឺ spec.rs នោះវាល extension នឹងជា .rs ។

2.2 បំបែកឯកសារទៅជា កំណាត់

បន្ទាប់​មក យើង​នឹង​បំបែក​ឯកសារ​ជា​កំណាត់ៗ។ យើងប្រើមុខងារ SplitRecursively ដើម្បីបំបែកឯកសារទៅជាកំណាត់។ អ្នកអាចស្វែងរកឯកសារសម្រាប់មុខងារ នៅទីនេះ ។

CocoIndex ផ្តល់នូវការគាំទ្រដែលភ្ជាប់មកជាមួយសម្រាប់ Tree-sitter ដូច្នេះអ្នកអាចបញ្ជូនជាភាសាទៅកាន់ប៉ារ៉ាម៉ែត្រ language ។ ដើម្បីមើលឈ្មោះភាសា និងផ្នែកបន្ថែមដែលគាំទ្រទាំងអស់ សូមមើលឯកសារ នៅទីនេះ ។ ភាសាសំខាន់ៗទាំងអស់ត្រូវបានគាំទ្រ ឧ. Python, Rust, JavaScript, TypeScript, Java, C++ ។ល។ ប្រសិនបើវាមិនបានបញ្ជាក់ ឬភាសាដែលបានបញ្ជាក់មិនត្រូវបានគាំទ្រ វានឹងចាត់ទុកជាអត្ថបទធម្មតា។

 with data_scope["files"].row() as file: # ... file["chunks"] = file["content"].transform( cocoindex.functions.SplitRecursively(), language=file["extension"], chunk_size=1000, chunk_overlap=300)

2.3 បង្កប់ បំណែក

យើងនឹងប្រើមុខងារ SentenceTransformerEmbed ដើម្បីបង្កប់កំណាត់។ អ្នកអាចស្វែងរកឯកសារសម្រាប់មុខងារ នៅទីនេះ ។ មានម៉ូដែល 12k គាំទ្រដោយ 🤗 Hugging Face ។ អ្នកគ្រាន់តែអាចជ្រើសរើសម៉ូដែលដែលអ្នកចូលចិត្ត។

 def code_to_embedding(text: cocoindex.DataSlice) -> cocoindex.DataSlice: """ Embed the text using a SentenceTransformer model. """ return text.transform( cocoindex.functions.SentenceTransformerEmbed( model="sentence-transformers/all-MiniLM-L6-v2"))

បន្ទាប់មកសម្រាប់កំណាត់នីមួយៗ យើងនឹងបង្កប់វាដោយប្រើមុខងារ code_to_embedding ។ ហើយប្រមូលការបង្កប់ទៅអ្នកប្រមូល code_embeddings ។

យើងទាញយកមុខងារ code_to_embedding នេះជំនួសឱ្យការហៅដោយផ្ទាល់ transform(cocoindex.functions.SentenceTransformerEmbed(...)) នៅនឹងកន្លែង។

នេះគឺដោយសារតែយើងចង់ធ្វើឱ្យមានការចែករំលែករវាងការបង្កើតលំហូរលិបិក្រម និងនិយមន័យកម្មវិធីដោះស្រាយសំណួរ។ ជាជម្រើសដើម្បីធ្វើឱ្យវាកាន់តែសាមញ្ញ។ វាក៏ជាការល្អផងដែរក្នុងការជៀសវាងមុខងារបន្ថែមនេះ ហើយធ្វើអ្វីៗដោយផ្ទាល់ - មិនមែនជារឿងធំទេក្នុងការចម្លងបិទភ្ជាប់បន្តិច យើងបានធ្វើវាសម្រាប់គម្រោង ការចាប់ផ្ដើមរហ័ស ។

 with data_scope["files"].row() as file: # ... with file["chunks"].row() as chunk: chunk["embedding"] = chunk["text"].call(code_to_embedding) code_embeddings.collect(filename=file["filename"], location=chunk["location"], code=chunk["text"], embedding=chunk["embedding"])

2.4 ប្រមូល ការបង្កប់

ជាចុងក្រោយ ចូរយើងនាំចេញការបង្កប់ទៅក្នុងតារាងមួយ។

 code_embeddings.export( "code_embeddings", cocoindex.storages.Postgres(), primary_key_fields=["filename", "location"], vector_index=[("embedding", cocoindex.VectorSimilarityMetric.COSINE_SIMILARITY)])

3. ដំឡើងកម្មវិធីដោះស្រាយសំណួរសម្រាប់ លិបិក្រម របស់អ្នក។

យើងនឹងប្រើ SimpleSemanticsQueryHandler ដើម្បីសួរលិបិក្រម។ ចំណាំថាយើងត្រូវឆ្លងកាត់មុខងារ code_to_embedding ទៅប៉ារ៉ាម៉ែត្រ query_transform_flow ។ នេះគឺដោយសារតែកម្មវិធីដោះស្រាយសំណួរនឹងប្រើគំរូបង្កប់ដូចគ្នាទៅនឹងអ្វីដែលបានប្រើនៅក្នុងលំហូរ។

 query_handler = cocoindex.query.SimpleSemanticsQueryHandler( name="SemanticsSearch", flow=code_embedding_flow, target_name="code_embeddings", query_transform_flow=code_to_embedding, default_similarity_metric=cocoindex.VectorSimilarityMetric.COSINE_SIMILARITY)

កំណត់មុខងារចម្បងដើម្បីដំណើរការកម្មវិធីដោះស្រាយសំណួរ។

 @cocoindex.main_fn() def _run(): # Run queries in a loop to demonstrate the query capabilities. while True: try: query = input("Enter search query (or Enter to quit): ") if query == '': break results, _ = query_handler.search(query, 10) print("\nSearch results:") for result in results: print(f"[{result.score:.3f}] {result.data['filename']}") print(f" {result.data['code']}") print("---") print() except KeyboardInterrupt: break if __name__ == "__main__": load_dotenv(override=True) _run()

អ្នកតុបតែង @cocoindex.main_fn() ចាប់ផ្តើមបណ្ណាល័យជាមួយនឹងការកំណត់ដែលបានផ្ទុកពីអថេរបរិស្ថាន។ សូមមើល ឯកសារសម្រាប់ការចាប់ផ្តើម សម្រាប់ព័ត៌មានលម្អិតបន្ថែម។

ដំណើរការការដំឡើងលិបិក្រម និង ធ្វើបច្ចុប្បន្នភាព

🎉 រួចរាល់ហើយ!

ដំណើរការពាក្យបញ្ជាខាងក្រោមដើម្បីដំឡើង និងធ្វើបច្ចុប្បន្នភាពលិបិក្រម។

 python main.py cocoindex setup python main.py cocoindex update

អ្នកនឹងឃើញស្ថានភាពអាប់ដេតលិបិក្រមនៅក្នុងស្ថានីយ

សាកល្បង សំណួរ

នៅចំណុចនេះ អ្នកអាចចាប់ផ្តើមម៉ាស៊ីនមេ cocoindex និងអភិវឌ្ឍពេលវេលាដំណើរការ RAG របស់អ្នកប្រឆាំងនឹងទិន្នន័យ។

ដើម្បីសាកល្បងសន្ទស្សន៍របស់អ្នក មានជម្រើសពីរ៖

ជម្រើសទី 1៖ ដំណើរការម៉ាស៊ីនមេលិបិក្រមនៅក្នុង ស្ថានីយ

 python main.py

នៅពេលអ្នកឃើញប្រអប់បញ្ចូល អ្នកអាចបញ្ចូលសំណួរស្វែងរករបស់អ្នក។ ឧទាហរណ៍៖ spec ។

 Enter search query (or Enter to quit): spec

អ្នកអាចស្វែងរកលទ្ធផលស្វែងរកនៅក្នុងស្ថានីយ

លទ្ធផលដែលបានត្រឡប់មកវិញ - ធាតុនីមួយៗមានពិន្ទុ (ភាពស្រដៀងគ្នានៃកូស៊ីនុស) ឈ្មោះឯកសារ និងព័ត៌មានសង្ខេបនៃកូដដែលត្រូវគ្នា។ នៅ cocoindex យើងប្រើ cocoindex.VectorSimilarityMetric.COSINE_SIMILARITY ដើម្បីវាស់ស្ទង់ភាពស្រដៀងគ្នារវាងសំណួរ និងទិន្នន័យដែលបានធ្វើលិបិក្រម។ អ្នក​អាច​ប្ដូរ​ទៅ​ម៉ែត្រ​ផ្សេង​ទៀត​ផង​ដែរ ហើយ​សាក​ល្បង​វា​យ៉ាង​ឆាប់​រហ័ស។

ដើម្បីស្វែងយល់បន្ថែមអំពី Consine Similarity សូមមើល Wiki ។

ជម្រើសទី 2៖ ដំណើរការ CocoInsight ដើម្បីយល់ពីបំពង់បញ្ជូនទិន្នន័យ និង សន្ទស្សន៍ ទិន្នន័យរបស់អ្នក។

CocoInsight គឺជាឧបករណ៍មួយដើម្បីជួយអ្នកឱ្យយល់អំពីបំពង់បញ្ជូនទិន្នន័យ និងសន្ទស្សន៍ទិន្នន័យរបស់អ្នក។ វាភ្ជាប់ទៅម៉ាស៊ីនមេ CocoIndex ក្នុងតំបន់របស់អ្នកជាមួយនឹងការរក្សាទុកទិន្នន័យសូន្យ។

CocoInsight គឺនៅក្នុង Early Access ឥឡូវនេះ (ឥតគិតថ្លៃ) 😊 អ្នកបានរកឃើញពួកយើងហើយ! ការបង្រៀនវីដេអូខ្លី 3 នាទីអំពី CocoInsight៖ មើលនៅលើ YouTube ។

ដំណើរការ ម៉ាស៊ីនមេ CocoIndex

 python main.py cocoindex server -c https://cocoindex.io

នៅពេលដែលម៉ាស៊ីនមេកំពុងដំណើរការ សូមបើក CocoInsight នៅក្នុងកម្មវិធីរុករករបស់អ្នក។ អ្នកនឹងអាចភ្ជាប់ទៅម៉ាស៊ីនមេ CocoIndex ក្នុងតំបន់របស់អ្នក និងរុករកបំពង់បង្ហូរទិន្នន័យ និងលិបិក្រមរបស់អ្នក។

នៅជ្រុងខាងស្តាំ អ្នកអាចមើលឃើញលំហូរទិន្នន័យដែលយើងបានកំណត់។

នៅផ្នែកខាងឆ្វេង អ្នកអាចមើលឃើញសន្ទស្សន៍ទិន្នន័យនៅក្នុងការមើលទិន្នន័យជាមុន។

អ្នកអាចចុចលើជួរណាមួយដើម្បីមើលព័ត៌មានលម្អិតនៃធាតុបញ្ចូលទិន្នន័យនោះ រួមទាំងខ្លឹមសារពេញលេញនៃកំណាត់កូដ និងការបង្កប់របស់វា។

សហគមន៍

យើងចូលចិត្តស្តាប់ពីសហគមន៍! អ្នកអាចស្វែងរកពួកយើងនៅលើ Github និង Discord ។

ប្រសិនបើអ្នកចូលចិត្តការបង្ហោះនេះ និងការងាររបស់យើង សូមគាំទ្រ CocoIndex នៅលើ Github ជាមួយនឹងផ្កាយ⭐។ អរគុណជាមួយនឹងការឱបដូងដ៏កក់ក្តៅ🥥🤗។