ಮೂಲಭೂತ RAG ಅನುಷ್ಠಾನ: ಹಂತ ಹಂತದ ಟ್ಯುಟೋರಿಯಲ್

ಆರಂಭಿಕರಿಗೆ ಸ್ನೇಹಿಯಾದ ಈ ಟ್ಯುಟೋರಿಯಲ್, ಮೂಲಭೂತ RAG ಅನುಷ್ಠಾನವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ, ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು Python, ChromaDB ಹಾಗೂ Perplexity ಯ ಎಂಬೆಡಿಂಗ್ ಮತ್ತು ಭಾಷಾ ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕಮಾಂಡ್-ಲೈನ್ RAG ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹಂತ ಹಂತವಾಗಿ ತಿಳಿಸುತ್ತದೆ.

Basic RAG implementation process diagram: the interface sends input to the orchestrator, which retrieves data from a vector database, builds the input context for the LLM, and returns the output to the interface.

RAG ಆಧುನಿಕ LLM-ಆಧಾರಿತ ಮೂಲಸೌಕರ್ಯದ ಅತ್ಯಗತ್ಯ ಘಟಕವಾಗಿದೆ. AI ಮಾದರಿಗಳಿಗೆ ಬಾಹ್ಯ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ಅವಕಾಶ ನೀಡುವ ಮೂಲಕ, ಇದು ಹ್ಯಾಲ್ಯುಸಿನೇಷನ್‌ಗಳು (ಭ್ರಮೆಗಳು) ಮತ್ತು ಅಪೂರ್ಣ ತರಬೇತಿ ಡೇಟಾದಂತಹ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಅಲ್ಲದೆ, ಸೂಕ್ಷ್ಮ ಅಥವಾ ಸ್ವಾಮ್ಯದ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಆಂತರಿಕ ಜ್ಞಾನ ಭಂಡಾರಗಳನ್ನು ಕಂಪನಿಗಳು ಬಳಸಬಹುದು ಎಂಬುದೂ ಇದರ ಅರ್ಥ.

RAG ಅನುಷ್ಠಾನವು ಅತ್ಯಂತ ಸಂಕೀರ್ಣವಾಗಿರಬಹುದು. ಆದಾಗ್ಯೂ, ಮೂಲಭೂತ RAG ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುವುದು ಆಶ್ಚರ್ಯಕರವಾಗಿ ಸುಲಭ. ಆರಂಭಿಕರಿಗೆ, ಸರಳವಾದ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ರಚಿಸುವುದರಿಂದ ನೈಜ ಜಗತ್ತಿನಲ್ಲಿ RAG ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಪ್ರಯೋಗಗಳಿಗೆ ಉತ್ತಮ ಆರಂಭಿಕ ವೇದಿಕೆ ದೊರೆಯುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ಮೂಲಭೂತ RAG ಅನುಷ್ಠಾನದ ರೂಪರೇಷೆಯನ್ನು ನೀಡುತ್ತೇವೆ, ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ವಿವರಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ Python, ChromaDB ಹಾಗೂ ಎಂಬೆಡಿಂಗ್ ಮತ್ತು ಉತ್ತರ ರಚನೆಗಾಗಿ ಎರಡು Perplexity ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವ್ಯವಸ್ಥೆಯೊಂದನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ.

ಮೂಲಭೂತ RAG ಅನುಷ್ಠಾನ ಪ್ರಕ್ರಿಯೆ: ಒಂದು ಸ್ಥೂಲ ಅವಲೋಕನ

ಮೂಲಭೂತ RAG ವ್ಯವಸ್ಥೆಯು ಮೂರು ಮುಖ್ಯ ಘಟಕಗಳನ್ನು ಹೊಂದಿದೆ: ಒಂದು ಆರ್ಕೆಸ್ಟ್ರೇಟರ್, ಒಂದು ಮಾಹಿತಿ ಮೂಲ ಮತ್ತು ಒಂದು LLM. ಸಾಮಾನ್ಯ ಕಾರ್ಯಪ್ರವಾಹದಲ್ಲಿ, ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ನಮೂದಿಸುತ್ತಾರೆ ಮತ್ತು ಸಂಪರ್ಕಿತ ಯಾವುದೇ ಮಾಹಿತಿ ಮೂಲಗಳಲ್ಲಿ ಹುಡುಕಲು ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಅದನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ. ನಂತರ ಹಿಂಪಡೆದ ಮಾಹಿತಿಯನ್ನು ಮೂಲ ಇನ್‌ಪುಟ್ ಸಂದರ್ಭಕ್ಕೆ ಸೇರಿಸಿ, ಉತ್ತರವನ್ನು ರಚಿಸಲು LLM ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

ನಿಮ್ಮ RAG ಅನುಷ್ಠಾನವನ್ನು ನಿರ್ಮಿಸುವಾಗ ನೀವು ಈ ಹಂತಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ:

  1. ಇಂಡೆಕ್ಸಿಂಗ್ ಮತ್ತು ಎಂಬೆಡಿಂಗ್: ಈ ಹಂತದಲ್ಲಿ, ನಿಮ್ಮ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಹುಡುಕಬಹುದಾದ ಮಾಹಿತಿ ಮೂಲವಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡುವ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದೆಂದರೆ ಹುಡುಕಬಹುದಾದ ವೆಕ್ಟರ್ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು. ನಿಮ್ಮ ಡಾಕ್ಯುಮೆಂಟ್ ತುಣುಕುಗಳನ್ನು ಎಂಬೆಡಿಂಗ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲು ನಾವು Perplexity ಯ ಮೀಸಲಾದ ಮಾದರಿಯನ್ನು ಬಳಸುತ್ತೇವೆ. ನಂತರ ಜನಪ್ರಿಯ ಓಪನ್-ಸೋರ್ಸ್ ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಆದ ChromaDB ಯಲ್ಲಿ ಎಂಬೆಡಿಂಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ.
  2. ಆರ್ಕೆಸ್ಟ್ರೇಷನ್: ಇದು ಬಾಹ್ಯ ಮಾಹಿತಿ ಮೂಲ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್) ಮತ್ತು LLM ನಡುವೆ ಇರುವ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ. ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ನಾವು ಸರಳ Python ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.
  3. ಹಿಂಪಡೆಯುವಿಕೆ ಮತ್ತು ರಚನೆ: ಬಳಕೆದಾರರು ಚಾಟ್ ಇಂಟರ್‌ಫೇಸ್ ಮೂಲಕ ಪ್ರಶ್ನೆ ಕೇಳಿದಾಗ, ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಅದನ್ನು ಸ್ವೀಕರಿಸಿ, ವೆಕ್ಟರ್ ಹುಡುಕಾಟವನ್ನು ನಡೆಸಿ, ವಿಸ್ತರಿತ ಇನ್‌ಪುಟ್ ಅನ್ನು LLM ಗೆ ನೀಡುತ್ತದೆ. ಮೀಸಲಾದ ಫ್ರಂಟ್‌ಎಂಡ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಬದಲು, ನಮ್ಮ Python ಆರ್ಕೆಸ್ಟ್ರೇಟರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ನಾವು ಕಮಾಂಡ್ ಲೈನ್ ಮೂಲಕ ಪ್ರಾಂಪ್ಟ್ ಮಾಡುತ್ತೇವೆ.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು: ಪರಿಣಾಮಕಾರಿ RAG ಅನುಷ್ಠಾನವನ್ನು ಯಾವುದು ರೂಪಿಸುತ್ತದೆ?

RAG ಆರ್ಕಿಟೆಕ್ಚರ್‌ನಲ್ಲಿ ಹಲವು ವಿಧಗಳಿವೆ ಮತ್ತು ಪ್ರತ್ಯೇಕ ಬಳಕೆಯ ಸಂದರ್ಭಗಳಿಗೆ ವಿಭಿನ್ನ ವಿಧಾನಗಳು ಬೇಕಾಗುತ್ತವೆ. ಹಾಗಿದ್ದರೂ, ಹಲವಾರು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಿಗೂ ಅನ್ವಯಿಸುತ್ತವೆ ಮತ್ತು ನಿಖರವಾದ, ವೆಚ್ಚ-ಪರಿಣಾಮಕಾರಿ, ವಿಸ್ತರಿಸಬಹುದಾದ ಹಾಗೂ ನಿರ್ವಹಿಸಲು ಸುಲಭವಾದ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ.

ಈ ಕೆಳಗಿನ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಎಲ್ಲಾ ರೀತಿಯ RAG ಅನುಷ್ಠಾನಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತವೆ:

  • ಸ್ವಚ್ಛವಾದ ಇಂಜೆಶನ್ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ: ಇಂಡೆಕ್ಸಿಂಗ್‌ಗೆ ಮೊದಲು ನಿಮ್ಮ ಮೂಲ ಡೇಟಾ ಸಾಧ್ಯವಾದಷ್ಟು ಸ್ವಚ್ಛವಾಗಿರಬೇಕು. ನಿಮ್ಮ ವಿಷಯಕ್ಕೆ ಸೂಕ್ತವಾದ ಎಂಬೆಡಿಂಗ್ ಮಾದರಿಯನ್ನೂ ನೀವು ಬಳಸಬೇಕು.
  • ಹೈಬ್ರಿಡ್ ಹುಡುಕಾಟವನ್ನು ಬಳಸಿ: ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಹುಡುಕಾಟ, API-ಆಧಾರಿತ ವೆಬ್ ಹುಡುಕಾಟ, ನಾಲೆಡ್ಜ್ ಗ್ರಾಫ್ ಸಂಚರಣೆ, ಕೀವರ್ಡ್ ಹುಡುಕಾಟ ಅಥವಾ ಇತರ ಯಾವುದೇ ವಿಧಾನವಾಗಿರಲಿ, ಅತ್ಯುತ್ತಮ ಹಿಂಪಡೆಯುವ ವಿಧಾನಗಳು ಬಳಕೆಯ ಸಂದರ್ಭವನ್ನು ಅವಲಂಬಿಸಿ ಬದಲಾಗುತ್ತವೆ. ವೆಚ್ಚವನ್ನು ಕನಿಷ್ಠಗೊಳಿಸಲು ಸರಿಯಾದ ಸಂಯೋಜನೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಮುಖ್ಯ.
  • ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ: ಅನುಷ್ಠಾನದ ನಂತರ, ನೀವು ಮೂರು ಪ್ರಮುಖ ಮಾನದಂಡಗಳ ಆಧಾರದ ಮೇಲೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡಬೇಕು: ನಿಖರತೆ, ಪ್ರಸ್ತುತತೆ ಮತ್ತು ಲೇಟೆನ್ಸಿ. ನಿಖರತೆ ಎಂದರೆ ಮಾಹಿತಿಯ ವಾಸ್ತವಿಕ ಸರಿತನ; ಪ್ರಸ್ತುತತೆ ಎಂದರೆ ಹಿಂಪಡೆದ ಮಾಹಿತಿಯು ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಗಳಿಗೆ ಎಷ್ಟು ಅನ್ವಯಿಸುತ್ತದೆ ಎಂಬುದು; ಮತ್ತು ಲೇಟೆನ್ಸಿ ಎಂದರೆ ಮಾಹಿತಿಯನ್ನು ಹಿಂಪಡೆಯುವ ವೇಗ.
  • ಮಾಹಿತಿಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ನಿರ್ವಹಿಸಿ: ನಿಮ್ಮ RAG ವ್ಯವಸ್ಥೆಯು ಖಾಸಗಿ ಆಂತರಿಕ ಮಾಹಿತಿಯನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಅದನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಮತ್ತು ವ್ಯವಸ್ಥೆಯ ಇಂಟರ್‌ಫೇಸ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. API ಕೀಗಳನ್ನು ಎಂದಿಗೂ ಹಂಚಿಕೊಳ್ಳಬಾರದು.

ಮೂಲಭೂತ RAG ಅನುಷ್ಠಾನ: 7 ಹಂತಗಳ ಟ್ಯುಟೋರಿಯಲ್

ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನಲ್ಲಿ, ಒಂದೇ ಡಾಕ್ಯುಮೆಂಟ್ ಕುರಿತ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುವ ಕಮಾಂಡ್-ಲೈನ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಾವು ನಿರ್ಮಿಸುತ್ತೇವೆ. ನಾವು Python, ChromaDB ಮತ್ತು Perplexity API ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

ಪ್ರೊಡಕ್ಷನ್‌ಗೆ ಸಿದ್ಧವಾದ RAG ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುವುದು ಇದರ ಉದ್ದೇಶವಲ್ಲ. ಬದಲಿಗೆ, ಪ್ರಾಥಮಿಕ RAG ಆರ್ಕಿಟೆಕ್ಚರ್ ಪ್ರಾಯೋಗಿಕವಾಗಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ, ಆರಂಭಿಕರಿಗೆ ಸ್ನೇಹಿಯಾದ ಟ್ಯುಟೋರಿಯಲ್ ಇದಾಗಿದೆ.

ಹಂತ 1: ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ

ಈ ಕೆಳಗಿನವು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಇನ್‌ಸ್ಟಾಲ್ ಆಗಿವೆಯೇ ಮತ್ತು ನಿಮ್ಮ ಬಳಿ Perplexity API ಖಾತೆ ಇದೆಯೇ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:

  • Python: ಇದು ಎಂಬೆಡಿಂಗ್ ಮಾದರಿ, ChromaDB ಮತ್ತು Perplexity ನಡುವಿನ ಡೇಟಾ ಹರಿವನ್ನು ಸಂಯೋಜಿಸುವ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಬಳಸುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದೆ.
  • Visual Studio: ನಾವು Visual Studio ಅನ್ನು ಕೋಡ್ ಎಡಿಟರ್ ಆಗಿ ಬಳಸುತ್ತೇವೆ. ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ ನಂತರ, Extensions ಪ್ಯಾನೆಲ್ ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು Python ಎಕ್ಸ್‌ಟೆನ್ಶನ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ.
  • Perplexity API ಖಾತೆ: Perplexity ಎಂಬೆಡಿಂಗ್ ಮಾದರಿ (ಇದು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ವೆಕ್ಟರ್ ಎಂಬೆಡಿಂಗ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ) ಮತ್ತು ವಿಸ್ತರಿತ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ LLM ಎರಡನ್ನೂ ಒದಗಿಸುತ್ತದೆ. ಇದಕ್ಕಾಗಿ ನಿಮಗೆ ಪಾವತಿಸಿದ ಖಾತೆಯ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೂ ಸ್ವಲ್ಪ ಕ್ರೆಡಿಟ್ ವೆಚ್ಚವಾಗುತ್ತದೆ.

ಹಂತ 2: ಪ್ರಾಜೆಕ್ಟ್ ಫೋಲ್ಡರ್ ಅನ್ನು ರಚಿಸಿ

ಮೊದಲಿಗೆ rag-project ಎಂಬ ಹೆಸರಿನ ಫೋಲ್ಡರ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು File > Open Folder ಆಯ್ಕೆ ಮಾಡುವ ಮೂಲಕ ಅದನ್ನು VS Code ನಲ್ಲಿ ತೆರೆಯಿರಿ. ನಂತರ ಇಂಟಿಗ್ರೇಟೆಡ್ ಟರ್ಮಿನಲ್ ತೆರೆಯಲು ಇದನ್ನು ಆಯ್ಕೆಮಾಡಿ: Terminal > New Terminal.

ವರ್ಚುವಲ್ Python ಪರಿಸರವನ್ನು ರಚಿಸಲು ಈ ಕೆಳಗಿನದನ್ನು ನಮೂದಿಸಿ:

bash
py -3.12 -m venv .venv

ಈಗ ನೀವು ನಾಲ್ಕು Python ಲೈಬ್ರರಿಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಬೇಕು: perplexityai, chromadb, python-dotenv ಮತ್ತು numpy. Perplexity SDK, API ಮೂಲಕ Perplexity ಯ ಮಾದರಿಗಳಿಗೆ ಸಂಪರ್ಕಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ChromaDB ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ ಮತ್ತು ಸ್ಥಳೀಯವಾಗಿ ಚಲಿಸುತ್ತದೆ. Python-dotenv ಸ್ಥಳೀಯ ಫೈಲ್‌ನಿಂದ ನಿಮ್ಮ API ಕೀಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇಂಜೆಶನ್ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ NumPy ಅಗತ್ಯವಿರುತ್ತದೆ.

ಈ ಕೆಳಗಿನ ಕಮಾಂಡ್ ಬಳಸಿ ಇವುಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ:

bash
.\.venv\Scripts\python.exe -m pip install perplexityai chromadb python-dotenv numpy

ಹಂತ 3: ನಿಮ್ಮ ಫೈಲ್‌ಗಳನ್ನು ಸೆಟ್ ಅಪ್ ಮಾಡಿ

rag-project (ಪ್ರಾಜೆಕ್ಟ್ ರೂಟ್) ಗೆ ಈ ಕೆಳಗಿನ ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸಲು, Explorer ಸೈಡ್‌ಬಾರ್‌ನಲ್ಲಿ New File… ಆಯ್ಕೆಮಾಡಿ:

  • index.py: ಇದು ನಿಮ್ಮ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಇಂಡೆಕ್ಸ್ ಮಾಡುವ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ. ಹೆಚ್ಚಿನ ಪಠ್ಯವನ್ನು ಸೇರಿಸಲು ನೀವು ಇದನ್ನು ಮತ್ತೆ ಚಲಾಯಿಸಬಹುದು.
  • rag.py: ಇದು ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ Python ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ.
  • document.txt: ನೀವು ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಆಗಿ ಪರಿವರ್ತಿಸುವ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಇದು ಒಳಗೊಂಡಿರುತ್ತದೆ.
  • .env: ಇಲ್ಲಿ ನೀವು ನಿಮ್ಮ Perplexity API ಕೀಯನ್ನು ಇರಿಸುತ್ತೀರಿ.

.env ನಲ್ಲಿ ಈ ಕೆಳಗಿನದನ್ನು ನಮೂದಿಸಿ:

plaintext
PERPLEXITY_API_KEY=your_api_key_here

your_api_key_here ಅನ್ನು ನಿಮ್ಮ ನಿಜವಾದ ಕೀಯೊಂದಿಗೆ ಬದಲಾಯಿಸಿ. ಇದಕ್ಕಾಗಿ, ನೀವು Perplexity API Console ನ ಹೋಮ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗೆ ಹೋಗಿ Create an API key ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಈ API ಕೀಯನ್ನು ಖಾಸಗಿಯಾಗಿ ಇರಿಸಿ.

ನಾವು ಎರಡು ಮಾದರಿಗಳನ್ನು ಬಳಸುತ್ತೇವೆ: ChromaDB ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡುವ ಮೊದಲು ನಮ್ಮ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಎಂಬೆಡ್ ಮಾಡಲು Perplexity ಯ pplx-embed-v1-0.6b ಮತ್ತು ಹಿಂಪಡೆದ ಮಾಹಿತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು GPT-5.6-Luna (Perplexity ಯ API ಮೂಲಕ ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ).

document.txt ನಲ್ಲಿ, ನಿಮ್ಮ RAG ಪೈಪ್‌ಲೈನ್ ಹಿಂಪಡೆಯುವ ಪಠ್ಯವನ್ನು ಸೇರಿಸಿ. ನಿಮ್ಮ ಬಳಿ ಸದ್ಯಕ್ಕೆ ಯಾವುದೇ ಡಾಕ್ಯುಮೆಂಟ್ ಇಲ್ಲದಿದ್ದರೆ, ಈ ಟ್ಯುಟೋರಿಯಲ್‌ಗಾಗಿ Project Gutenberg ನಿಂದ ವಿಲಿಯಂ ಬ್ಲೇಕ್ ಅವರ Songs of Innocence and of Experience ಅನ್ನು ಬಳಸಿ. ಇದು ಸಾರ್ವಜನಿಕ ಡೊಮೇನ್‌ನಲ್ಲಿರುವ, ಚಿಕ್ಕದಾದ ಮತ್ತು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದಾದ ಪಠ್ಯವಾಗಿದೆ.

ಹಂತ 4: ಇಂಡೆಕ್ಸಿಂಗ್ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯಿರಿ

ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಕಾಪಿ ಮಾಡಿ index.py ಗೆ ಪೇಸ್ಟ್ ಮಾಡಿ. ಪ್ರತಿಯೊಂದು ಉಪಶೀರ್ಷಿಕೆಯು ಅದರ ನಂತರದ ಕೋಡ್ ಭಾಗವು ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದರ ಸಂಕ್ಷಿಪ್ತ ವಿವರಣೆಯನ್ನು ನೀಡುತ್ತದೆ. Perplexity ಯ ಎಂಬೆಡಿಂಗ್ ಮಾದರಿ pplx-embed-v1-0.6b ಮತ್ತು NumPy ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು, ನಿಮ್ಮ ಮೂಲ ಸಾಮಗ್ರಿಯನ್ನು ವೆಕ್ಟರ್ ಎಂಬೆಡಿಂಗ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಿ ChromaDB ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುವ ಪ್ರೋಗ್ರಾಂ ಇದಾಗಿದೆ.

ಪ್ರೋಗ್ರಾಂ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

  1. document.txt ಅನ್ನು ತೆರೆಯುತ್ತದೆ.
  2. ಪಠ್ಯವನ್ನು ಪರಸ್ಪರ ಅತಿಕ್ರಮಿಸುವ ತುಣುಕುಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ.
  3. ಆ ತುಣುಕುಗಳನ್ನು Perplexity ಯ pplx-embed-v1-0.6b ಎಂಬೆಡಿಂಗ್ ಮಾದರಿಗೆ ಕಳುಹಿಸುತ್ತದೆ.
  4. ಕಂಪ್ಯೂಟಿಂಗ್ ಫಂಕ್ಷನ್‌ಗಳ Python ಲೈಬ್ರರಿಯಾದ NumPy ಬಳಸಿ, ಹಿಂತಿರುಗಿದ ವೆಕ್ಟರ್‌ಗಳನ್ನು ಡಿಕೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾರ್ಮಲೈಸ್ ಮಾಡುತ್ತದೆ.
  5. ವೆಕ್ಟರ್‌ಗಳು ಮತ್ತು ಮೂಲ ತುಣುಕುಗಳನ್ನು ChromaDB ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ (ಇದು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ).

ನೀವು ಪ್ರತಿ ಬಾರಿ ಚಲಾಯಿಸಿದಾಗಲೂ ನಿಮ್ಮ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಮರು-ಇಂಡೆಕ್ಸ್ ಮಾಡದಂತೆ ಇದನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ. ನೀವು document.txt ನಲ್ಲಿರುವ ಮಾಹಿತಿಗೆ ಏನನ್ನಾದರೂ ಸೇರಿಸಿದರೆ, ಅದು ಹೊಸ ಪಠ್ಯವನ್ನು ಮಾತ್ರ ಎಂಬೆಡ್ ಮಾಡುತ್ತದೆ.

python
from pathlib import Path from collections import defaultdict, deque from hashlib import sha256 import base64 import numpy as np import chromadb from dotenv import load_dotenv from perplexity import Perplexity # 1. Connect to Perplexity and ChromaDB load_dotenv() ai = Perplexity() db = chromadb.PersistentClient(path="./rag_database_perplexity") collection = db.get_or_create_collection( name="documents", metadata={"hnsw:space": "cosine"} ) # Convert Perplexity's encoded embeddings into numerical vectors def decode_embedding(encoded): vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32) norm = np.linalg.norm(vector) if norm == 0: raise ValueError("Received a zero-length embedding vector.") return (vector / norm).tolist() # 2. Read the document and split it into chunks text = Path("document.txt").read_text(encoding="utf-8") words = text.split() chunk_size = 180 overlap = 30 step = chunk_size - overlap chunks = [" ".join(words[i:i + chunk_size]) for i in range(0, len(words), step)] if not chunks: raise ValueError("document.txt is empty.") # 3. Retrieve the chunks already stored in ChromaDB existing = collection.get(include=["documents"]) stored_chunks = defaultdict(deque) existing_ids = set(existing["ids"]) for chunk_id, document in zip(existing["ids"], existing["documents"]): stored_chunks[document].append(chunk_id) # 4. Identify unchanged and new chunks new_chunks = [] new_ids = [] kept_ids = set() unchanged = 0 for chunk in chunks: if stored_chunks[chunk]: chunk_id = stored_chunks[chunk].popleft() kept_ids.add(chunk_id) unchanged += 1 else: chunk_hash = sha256(chunk.encode("utf-8")).hexdigest() chunk_id = f"chunk-{chunk_hash}" suffix = 1 while chunk_id in existing_ids or chunk_id in kept_ids or chunk_id in new_ids: chunk_id = f"chunk-{chunk_hash}-{suffix}" suffix += 1 new_chunks.append(chunk) new_ids.append(chunk_id) kept_ids.add(chunk_id) # 5. Generate embeddings in batches of up to 100 chunks batch_size = 100 for i in range(0, len(new_chunks), batch_size): batch_chunks = new_chunks[i:i + batch_size] batch_ids = new_ids[i:i + batch_size] embeddings = ai.embeddings.create( model="pplx-embed-v1-0.6b", input=batch_chunks, encoding_format="base64_int8" ) vectors = [decode_embedding(item.embedding) for item in embeddings.data] # 6. Store each batch in ChromaDB collection.upsert( ids=batch_ids, documents=batch_chunks, embeddings=vectors ) print(f"Indexed batch {(i // batch_size) + 1}") # 7. Remove outdated chunks old_ids = [chunk_id for chunk_id in existing["ids"] if chunk_id not in kept_ids] if old_ids: collection.delete(ids=old_ids) # 8. Display indexing results print("Indexing complete!") print("Unchanged chunks:", unchanged) print("New or modified chunks:", len(new_chunks)) print("Removed chunks:", len(old_ids)) print("Total stored chunks:", collection.count())

ಹಂತ 5. RAG ವ್ಯವಸ್ಥೆಗಾಗಿ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಅನ್ನು ಬರೆಯಿರಿ

ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಕಾಪಿ ಮಾಡಿ rag.py ಗೆ ಪೇಸ್ಟ್ ಮಾಡಿ. ಇದು Perplexity SDK ಮತ್ತು ChromaDB ಯ ಸ್ಥಳೀಯ ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯವನ್ನು ಬಳಸುವ, ಸಂಪೂರ್ಣವಾದರೂ ಕನಿಷ್ಠ RAG ಅನುಷ್ಠಾನವಾಗಿದೆ.

ನೀವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಿದಾಗ ಏನಾಗುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

  1. Perplexity ಮತ್ತು ನಿಮ್ಮ ಹೊಸ ChromaDB ಡೇಟಾಬೇಸ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ.
  2. ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಇಂಡೆಕ್ಸ್ ಮಾಡಲಾದ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
  3. ಬಳಕೆದಾರರಿಂದ ಪ್ರಶ್ನೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.
  4. ಪ್ರಶ್ನೆಯನ್ನು Perplexity ಯ ಎಂಬೆಡಿಂಗ್ ಮಾದರಿಗೆ ಕಳುಹಿಸುತ್ತದೆ.
  5. NumPy ಬಳಸಿ, ಫಲಿತಾಂಶವಾಗಿ ಬಂದ ಎಂಬೆಡಿಂಗ್ ಅನ್ನು ಡಿಕೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾರ್ಮಲೈಸ್ ಮಾಡುತ್ತದೆ.
  6. ಅತ್ಯಂತ ಹೋಲುವ ಮೂರು ಡಾಕ್ಯುಮೆಂಟ್ ತುಣುಕುಗಳಿಗಾಗಿ ChromaDB ಯಲ್ಲಿ ಹುಡುಕುತ್ತದೆ.
  7. ಹಿಂಪಡೆದ ತುಣುಕುಗಳು ಮತ್ತು ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆಯನ್ನು ಒಳಗೊಂಡ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
  8. Perplexity ಯ ಏಜೆಂಟ್ API ಮೂಲಕ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು GPT-5.6 Luna ಗೆ ಕಳುಹಿಸುತ್ತದೆ.
  9. ಉತ್ತರವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ ಮತ್ತು ಮುಂದಿನ ಪ್ರಶ್ನೆಗಾಗಿ ಕಾಯುತ್ತದೆ.
python
import base64 import numpy as np import chromadb from dotenv import load_dotenv from perplexity import Perplexity # 1. Connect to Perplexity and the existing ChromaDB database load_dotenv() ai = Perplexity() db = chromadb.PersistentClient(path="./rag_database_perplexity") collection = db.get_collection("documents") # Convert Perplexity's encoded embeddings into numerical vectors def decode_embedding(encoded): vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32) norm = np.linalg.norm(vector) if norm == 0: raise ValueError("Received a zero-length embedding vector.") return (vector / norm).tolist() # 2. Check that the database contains indexed documents count = collection.count() if count == 0: raise ValueError("The database is empty. Run index.py first.") print("Connected to existing ChromaDB database.") print("Stored chunks:", count) # 3. Accept questions from the user while True: question = input("\nAsk a question (or type exit): ") if question.lower().strip() == "exit": break if not question.strip(): continue # 4. Convert the question into a Perplexity embedding question_response = ai.embeddings.create( model="pplx-embed-v1-0.6b", input=[question], encoding_format="base64_int8" ) question_vector = decode_embedding(question_response.data[0].embedding) # 5. Retrieve the most similar document chunks from ChromaDB results = collection.query( query_embeddings=[question_vector], n_results=min(3, count) ) context = "\n\n".join(results["documents"][0]) # 6. Construct a prompt and send it to the fixed LLM response = ai.responses.create( model="openai/gpt-5.6-luna", instructions=( "Answer using only the supplied document excerpts. " "Do not use external information. " "If the answer is not present, say you don't know." ), input=f"Document excerpts:\n{context}\n\nQuestion: {question}" ) # 7. Display the answer print("\nAnswer:\n", response.output_text)

ಹಂತ 6: ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಚಲಾಯಿಸಿ

document.txt ನಲ್ಲಿರುವ ವಿಷಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡಲು, VS Code PowerShell ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನದನ್ನು ನಮೂದಿಸಿ:

bash
.\.venv\Scripts\python.exe index.py

ನಿಮ್ಮ ಡಾಕ್ಯುಮೆಂಟ್ ಯಶಸ್ವಿಯಾಗಿ ಇಂಡೆಕ್ಸ್ ಆಗಿದ್ದರೆ, ಇದಕ್ಕೆ ಹೋಲುವ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೀವು ನೋಡಬೇಕು:

plaintext
Indexing complete! Unchanged chunks: 0 New or modified chunks: 58 Removed chunks: 0 Total stored chunks: 58

ಈಗ ಮುಖ್ಯ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸುವ ಸಮಯ. ಈ ಕಮಾಂಡ್ ಅನ್ನು ನಮೂದಿಸಿ:

bash
.\.venv\Scripts\python.exe rag.py

ಇದು ಯಶಸ್ವಿಯಾಗಿ ಚಲಿಸಿದರೆ, ನೀವು ಈ ಕೆಳಗಿನದನ್ನು ನೋಡುತ್ತೀರಿ:

plaintext
Connected to existing ChromaDB database. Stored chunks: 58 Ask a question (or type exit):

ನೀವು ರಚಿಸಿದ ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್‌ನಿಂದ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುವ ಪ್ರಶ್ನೆಗಳನ್ನು ಈಗ ನೀವು ಕೇಳಬಹುದು, ಉದಾಹರಣೆಗೆ:

plaintext
Ask a question (or type exit): What animals does William Blake talk about? Answer: The excerpts mention sheep, lambs, birds, beasts, wolves, tigers, and a lion.

ಹಂತ 7: ನೀವು ನಿರ್ಮಿಸಿರುವುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ

ನೀವು ನಿರ್ಮಿಸಿರುವ ವ್ಯವಸ್ಥೆಯು ಪ್ರತಿಯೊಂದು RAG ಆರ್ಕಿಟೆಕ್ಚರ್‌ನಲ್ಲಿರುವ ಎರಡು ಪ್ರಮುಖ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ಇಂಡೆಕ್ಸಿಂಗ್ ಅಥವಾ “ಇಂಜೆಶನ್” ಪೈಪ್‌ಲೈನ್, ಮತ್ತು ಹಿಂಪಡೆಯುವಿಕೆ ಹಾಗೂ ರಚನೆಯ ಪೈಪ್‌ಲೈನ್.

ನಿಮ್ಮ ಮೂಲಭೂತ RAG ಅನುಷ್ಠಾನವು ಈಗ ಈ ಕೆಳಗಿನ ಎಲ್ಲವನ್ನೂ ಮಾಡುತ್ತದೆ:

  • ವೆಕ್ಟರ್ ಸಂಗ್ರಹಣೆ: ನಿಮ್ಮ ಜ್ಞಾನ ಫೈಲ್ ಆಧರಿಸಿ, ಎಂಬೆಡಿಂಗ್‌ಗಳನ್ನು ನಿಮ್ಮ ಸ್ಥಳೀಯ ಪರಿಸರದಲ್ಲಿರುವ ChromaDB ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ.
  • ಹಂತಹಂತದ ಇಂಡೆಕ್ಸಿಂಗ್: ಬದಲಾಗದ ಡಾಕ್ಯುಮೆಂಟ್ ತುಣುಕುಗಳನ್ನು ಮತ್ತೆ ಎಂಬೆಡ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ನೀವು ಬಯಸಿದಾಗಲೆಲ್ಲಾ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಬಹುದು.
  • ಸೆಮ್ಯಾಂಟಿಕ್ ಹಿಂಪಡೆಯುವಿಕೆ: ChromaDB ವೆಕ್ಟರ್ ಹೋಲಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ತುಣುಕುಗಳನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ (ಇದನ್ನು ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಪ್ರಾರಂಭಿಸುತ್ತದೆ).
  • ಆಧಾರಸಹಿತ ಉತ್ತರ ರಚನೆ: LLM ಹಿಂಪಡೆದ ಭಾಗಗಳನ್ನು ಸಂದರ್ಭವಾಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಉತ್ತರದಲ್ಲಿ ಅಳವಡಿಸಿಕೊಳ್ಳುತ್ತದೆ.
  • ಸ್ವತಂತ್ರ ಇಂಡೆಕ್ಸಿಂಗ್ ಮತ್ತು ಪ್ರಶ್ನಿಸುವಿಕೆ: ನಿಮ್ಮ ಜ್ಞಾನ ಫೈಲ್‌ನಲ್ಲಿರುವ ಸಂಪೂರ್ಣ ಪಠ್ಯವನ್ನು ಮರುಸಂಸ್ಕರಿಸದೆಯೇ ನೀವು ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಬಹುದು.
  • API-ಆಧಾರಿತ ಮಾದರಿ ಸಂಪರ್ಕ: ಎಲ್ಲಾ ಉತ್ತರಗಳನ್ನು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಚಲಿಸುವ ಮಾದರಿಯ ಬದಲು, Perplexity ಮೂಲಕ GPT-5.6 Luna ಬಳಸಿ ರಚಿಸಲಾಗುತ್ತದೆ.

ಮುಂದಿನ ಹಂತಗಳು: ಈ ಅನುಷ್ಠಾನವನ್ನು ಇನ್ನಷ್ಟು ಮುಂದುವರಿಸುವುದು ಹೇಗೆ

ಸರಳವಾದ, ಮೂಲಭೂತ ಅನುಷ್ಠಾನವನ್ನು ನಿರ್ಮಿಸುವುದು ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನ ಉದ್ದೇಶವಾಗಿದೆ. ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿರುವ ಕೆಲವು ಪ್ರಮುಖ RAG ಆರ್ಕಿಟೆಕ್ಚರ್ ಘಟಕಗಳನ್ನು ಇದು ಒಳಗೊಂಡಿದೆ. ನೀವು ಇನ್ನಷ್ಟು ಮುಂದುವರಿಯಲು ಬಯಸಿದರೆ, ಇದರ ಮೇಲೆ ನಿರ್ಮಿಸಲು ಹಲವು ಮಾರ್ಗಗಳಿವೆ.

ನಿಮ್ಮ ಅನುಷ್ಠಾನದ ವ್ಯಾಪ್ತಿಯನ್ನು ವಿಸ್ತರಿಸಲು ಕೆಲವು ಆಲೋಚನೆಗಳು ಇಲ್ಲಿವೆ:

  • LangChain ನೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಿ: LangChain ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಓಪನ್-ಸೋರ್ಸ್ ಆರ್ಕೆಸ್ಟ್ರೇಷನ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಸಂಕೀರ್ಣ RAG ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಚಲಾಯಿಸಬಲ್ಲ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇದು ಮೊದಲೇ ನಿರ್ಮಿಸಲಾದ ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
  • ಹುಡುಕಾಟ ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸಿ: ಡೆನ್ಸ್ ವೆಕ್ಟರ್ ಹುಡುಕಾಟವನ್ನು BM25 ನಂತಹ ಲೆಕ್ಸಿಕಲ್ (ಕೀವರ್ಡ್) ಹುಡುಕಾಟದೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ. Perplexity Search API ಮೂಲಕ ವೆಬ್ ಹುಡುಕಾಟವನ್ನು ಸೇರಿಸುವುದರಿಂದ, ಪ್ರಸ್ತುತ ಡೇಟಾವನ್ನು ಆಧರಿಸಿ ಉತ್ತರಗಳನ್ನು ನೀಡಲು ಸಹ ಸಾಧ್ಯವಾಗುತ್ತದೆ.
  • ಮರು-ಶ್ರೇಣೀಕರಣ ಮಾದರಿಯನ್ನು ಸೇರಿಸಿ: ಹಿಂಪಡೆದ ಭಾಗಗಳನ್ನು ಆರಂಭಿಕ ಪ್ರಾಂಪ್ಟ್‌ಗೆ ಹೋಲಿಸಿ ಶ್ರೇಣೀಕರಿಸುವ ಮತ್ತು LLM ಗೆ ಒದಗಿಸುವ ಇನ್‌ಪುಟ್ ಸಂದರ್ಭದಲ್ಲಿ ಸೇರಿಸಲು ಅತ್ಯಂತ ಸೂಕ್ತವಾದವುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಮರು-ಶ್ರೇಣೀಕರಣ ಮಾದರಿಯನ್ನು ಸಂಯೋಜಿಸಿ.
  • ಅಡಾಪ್ಟಿವ್ RAG ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಿ: ಮಾಡ್ಯುಲರ್ RAG ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಯಾವ ಹಿಂಪಡೆಯುವ ವಿಧಾನವನ್ನು ಬಳಸಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಅಡಾಪ್ಟಿವ್ RAG, LLM ಅಥವಾ ಕ್ಲಾಸಿಫೈಯರ್ (ಆರ್ಕೆಸ್ಟ್ರೇಟರ್‌ನೊಳಗಿನ ಒಂದು ಘಟಕ) ಅನ್ನು ಬಳಸುತ್ತದೆ. ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ RAG ಅನುಷ್ಠಾನಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಇದನ್ನು ನಿರ್ಮಿಸುವುದು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ.

ಇವೆಲ್ಲವೂ ಸಂಕೀರ್ಣವೆನಿಸಬಹುದಾದರೂ, Perplexity ಯಂತಹ ಮುಖ್ಯವಾಹಿನಿಯ AI ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ಸುಧಾರಿತ ಕೋಡಿಂಗ್ ಸಹಾಯವನ್ನು ಒದಗಿಸಬಲ್ಲವು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ವೈಯಕ್ತಿಕ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ಮತ್ತು ಪ್ರಯೋಗಗಳಿಗೆ ಅವು ಅತ್ಯುತ್ತಮವಾಗಿವೆ ಮತ್ತು ವೆಚ್ಚವನ್ನು ತುಲನಾತ್ಮಕವಾಗಿ ಕಡಿಮೆ ಇರಿಸಬಹುದು.

ಗಮನಿಸಿ: ಈ ಟ್ಯುಟೋರಿಯಲ್ GPT-5.6 Luna ಅನ್ನು ಬಳಸುತ್ತದೆ. ಮಾದರಿಯ ಲಭ್ಯತೆ ಬದಲಾಗಬಹುದು, ಆದ್ದರಿಂದ ನೀವು API ಕರೆಯನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಬೇಕಾಗಬಹುದು.