ਜ਼ਿਆਦਾਤਰ AI agents ਵਿੱਚ ਯਾਦ ਰੱਖਣ ਦੀ ਸ਼ਕਤੀ (recall) ਬਹੁਤ ਵਧੀਆ ਹੁੰਦੀ ਹੈ ਪਰ ਇਸ ਗੱਲ ਬਾਰੇ ਫੈਸਲਾ ਲੈਣ ਦੀ ਸਮਰੱਥਾ (judgment) ਬਹੁਤ ਮਾੜੀ ਹੁੰਦੀ ਹੈ ਕਿ ਕਿਸ ਚੀਜ਼ ਨੂੰ ਯਾਦ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਹ ਹਜ਼ਾਰਾਂ ਪੰਨਿਆਂ ਨੂੰ ਅੰਦਰ ਲੈ ਸਕਦੇ ਹਨ, ਫਿਰ ਵੀ ਆਪਣੇ ਹੀ ਸੰਦਰਭ (context) ਵਿੱਚ ਡੁੱਬ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਕਿਸੇ ਨੇ ਉਹਨਾਂ ਨੂੰ ਅਣਪ੍ਰਸੰਗਿਕ ਹਿੱਸਿਆਂ ਨੂੰ ਭੁੱਲਣਾ ਨਹੀਂ ਸਿਖਾਇਆ। Knowledge and Memory Management version 0.0.2 ਬਿਲਕੁਲ ਇਸੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਸੀ। ਇਹ ਕੋਈ ਮਾਮੂਲੀ ਪੈਚ ਨਹੀਂ ਹੈ। ਇਹ ਇਸ ਗੱਲ ਬਾਰੇ ਮੁੜ ਵਿਚਾਰ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ agent ਜੋ ਜਾਣਦਾ ਹੈ ਉਸਨੂੰ ਕਿਵੇਂ ਸਟੋਰ, ਟ੍ਰਾਂਸਪੋਰਟ ਅਤੇ ਪਹਿਲ ਦਿੱਤੀ ਜਾਵੇ।

ਮੈਮੋਰੀ ਦੀ ਸਮੱਸਿਆ

Agents ਰੋਜ਼ਾਨਾ ਟੈਕਸਟ ਦੇ ਹਰ ਟੁਕੜੇ ਨੂੰ ਪਵਿੱਤਰ ਮੰਨਦੇ ਹਨ। ਇੱਕ ਕੱਚਾ ਵੈੱਬ ਪੇਜ ਆਪਣੇ ਨੈਵੀਗੇਸ਼ਨ ਮੀਨੂ, ਕੁਕੀ ਬੈਨਰ ਅਤੇ ਫੁੱਟਰ ਲਿੰਕਾਂ ਦੇ ਨਾਲ ਸਟੋਰੇਜ ਵਿੱਚ ਡੇਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਵੀਡੀਓ ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਹਰ “um,” ਟਾਈਮਸਟੈਂਪ ਅਤੇ ਸਪਾਂਸਰ ਰੀਡ ਦੇ ਨਾਲ ਆਉਂਦੀ ਹੈ। ਇੱਕ ਲੇਖ ਵਿੱਚ ਅਸਲ ਜਾਣਕਾਰੀ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਵਿਗਿਆਪਨ-ਕਾਪੀ ਮਾਰਕਅੱਪ ਹੋ ਸਕਦਾ ਹੈ। ਜਦੋਂ ਰਿਟ੍ਰੀਵਲ (retrieval) ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸਿਸਟਮ ਸਹੀ ਜਾਣਕਾਰੀ ਲੱਭਣ ਲਈ ਇਸ ਸਾਰੇ ਸ਼ੋਰ (noise) ਵਿੱਚੋਂ ਛਾਣਨੀ ਕਰਦਾ ਹੈ। ਉਹ ਬਰਬਾਦੀ ਦੋ ਥਾਵਾਂ 'ਤੇ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ: ਤੁਹਾਡਾ context window ਫਾਲਤੂ ਚੀਜ਼ਾਂ ਨਾਲ ਘਟ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਡਾ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਬਿੱਲ ਵਧ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਬੇਮਤਲਬ ਟੈਕਸਟ ਨੂੰ ਪ੍ਰੋਸੈਸ ਅਤੇ ਐਂਬੈਡ ਕਰਨ ਲਈ ਪੈਸੇ ਦੇ ਰਹੇ ਹੋ।

ਸਕੇਲਿੰਗ ਦੀ ਸਮੱਸਿਆ ਵੀ ਉਨੀ ਹੀ ਨਿਰਾਸ਼ਾਜਨਕ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਸ਼ੁਰੂਆਤੀ ਪੜਾਅ ਦੇ agents ਹਾਰਡਕੋਡਡ ਪਾਥਾਂ (hardcoded paths) ਰਾਹੀਂ ਇੱਕ ਸਿੰਗਲ ਮਸ਼ੀਨ ਨਾਲ ਜੁੜੇ ਹੁੰਦੇ ਹਨ। ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਆਪਣੇ ਲੈਪਟਾਪ ਤੋਂ ਸਰਵਰ 'ਤੇ, ਜਾਂ ਇੱਕ VPS ਤੋਂ ਦੂਜੇ 'ਤੇ ਲੈ ਜਾਓ, ਅਤੇ ਤੁਸੀਂ ਟੁੱਟੇ ਹੋਏ ਰੈਫਰੈਂਸਾਂ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਕੰਫਿਗਰੇਸ਼ਨ ਫਾਈਲਾਂ ਵਿੱਚ grepping ਕਰਨ ਵਿੱਚ ਇੱਕ ਦੁਪਹਿਰ ਬਿਤਾ ਦਿੰਦੇ ਹੋ। Agent ਸੌਫਟਵੇਅਰ ਹੋਣਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਅਜਿਹੀ ਨਾਜ਼ੁਕ ਕਲਾ ਦੀ ਪ੍ਰਦਰਸ਼ਨੀ ਬਣ ਜਾਂਦਾ ਹੈ ਜੋ ਸਿਰਫ਼ ਇੱਕ ਕਮਰੇ ਵਿੱਚ ਹੀ ਰਹਿ ਸਕਦੀ ਹੈ।

V0.0.2 ਵਿੱਚ ਕੀ ਬਦਲਿਆ ਹੈ

ਇਹ ਰੀਲੀਜ਼ ਦੋਵਾਂ ਮੁੱਦਿਆਂ ਦਾ ਸਿੱਧਾ ਸਾਹਮਣਾ ਕਰਦੀ ਹੈ। ਇਹ ਇੱਕ ਪੋਰਟੇਬਲ ਪਾਥਿੰਗ ਸਕੀਮ ਅਤੇ ਇੱਕ ਇਕਸਾਰ ਸਮਰੀਜ਼ੇਸ਼ਨ ਪਾਈਪਲਾਈਨ (unified summarization pipeline) ਪੇਸ਼ ਕਰਦੀ ਹੈ ਜੋ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਗਿਆਨ ਨੂੰ ਸਾਫ਼ ਕਰ ਦਿੰਦੀ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਅਜਿਹਾ agent ਮਿਲਦਾ ਹੈ ਜਿਸ ਨੂੰ ਹਿਲਾਉਣਾ ਆਸਾਨ ਹੈ ਅਤੇ ਚਲਾਉਣਾ ਸਸਤਾ ਹੈ।

ਤੁਸੀਂ ਆਪਣੇ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਨਾਲ ਲੜਨਾ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹੋ। ਤੁਸੀਂ ਸੀਮਤ context ਵਿੱਚ ਫਾਲਤੂ ਦਸਤਾਵੇਜ਼ ਭਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹੋ। Agent ਬਸ ਬਿਹਤਰ ਯਾਦ ਰੱਖਦਾ ਹੈ।

$AGENT_HOME ਦੇ ਨਾਲ ਡਿਜ਼ਾਈਨ ਅਨੁਸਾਰ ਪੋਰਟੇਬਲ

ਸਭ ਤੋਂ ਵਿਹਾਰਕ ਬਦਲਾਅ $AGENT_HOME environment variable ਦੀ ਸ਼ੁਰੂਆਤ ਹੈ। ਹਰ ਪਾਥ ਜਿਸ ਨੂੰ ਸਿਸਟਮ ਛੂਹਦਾ ਹੈ—knowledge bases, working memory, cached summaries, session logs—ਇਸ ਰੂਟ ਦੇ ਸਾਪੇਖਿਕ (relative) ਹੁੰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਨੂੰ ਛੇੜੇ ਬਿਨਾਂ ਆਪਣੀ ਪੂਰੀ agent directory ਨੂੰ ਕਿਤੇ ਵੀ ਲੈ ਜਾ ਸਕਦੇ ਹੋ।

ਇੱਕ ਆਮ ਮਾਈਗ੍ਰੇਸ਼ਨ (migration) ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ। ਕੱਲ੍ਹ ਤੁਹਾਡਾ agent /srv/ai-agent 'ਤੇ ਇੱਕ DigitalOcean droplet 'ਤੇ ਸੀ। ਅੱਜ ਤੁਸੀਂ ਇਸਨੂੰ ਸਥਾਨਕ (locally) ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਕਿਸੇ ਸਾਥੀ ਨੂੰ ਸੌਂਪਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ JSON configs, Python scripts, ਅਤੇ shell wrappers ਵਿੱਚ ਖਿੰਡੇ ਹੋਏ ਹਾਰਡਕੋਡਡ ਐਬਸੋਲਿਊਟ ਪਾਥ ਮਿਲਦੇ ਸਨ। ਤੁਸੀਂ ਦਰਜਨਾਂ ਫਾਈਲਾਂ ਵਿੱਚ sed ਰਾਹੀਂ ਸੁਧਾਰ ਕਰਦੇ, ਉਮੀਦ ਕਰਦੇ ਅਤੇ ਅਰਦਾਸ ਕਰਦੇ ਕਿ ਤੁਸੀਂ ਹਰ ਰੈਫਰੈਂਸ ਨੂੰ ਫੜ ਲਿਆ ਹੈ। version 0.0.2 ਦੇ ਨਾਲ, ਤੁਸੀਂ ਇਸਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਛੱਡ ਦਿੰਦੇ ਹੋ। ਤੁਸੀਂ ਫੋਲਡਰ ਨੂੰ ਕਾਪੀ ਕਰਦੇ ਹੋ, export AGENT_HOME=/your/path ਸੈੱਟ ਕਰਦੇ ਹੋ, ਅਤੇ ਚਲਾਉਂਦੇ ਹੋ। Ingestion scripts, memory index, ਅਤੇ retrieval layer ਸਾਰੇ ਆਪਣੇ ਆਪ ਅਨੁਕੂਲ ਹੋ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ ਇਹ ਮੰਨਣ ਦੀ ਬਜਾਏ ਕਿ ਉਹ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹਨ, ਕਿ home ਕਿੱਥੇ ਹੈ, ਉਹ ऑपरेटिंग ਸਿਸਟਮ ਨੂੰ ਪੁੱਛਦੇ ਹਨ।

ਇਹ ਪੋਰਟੇਬਿਲਟੀ ਸਹੂਲਤ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇਹ ਤੁਹਾਡੇ ਸੈੱਟਅੱਪ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣ ਯੋਗ (reproducible) ਬਣਾਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਆਪਣੇ knowledge directory ਨੂੰ version control ਵਿੱਚ ਟ੍ਰੈਕ ਕਰ ਸਕਦੇ ਹੋ ਬਿਨਾਂ ਰੈਪੋਜ਼ਟਰੀ ਨੂੰ ਅਜਿਹੇ ਪਾਥਾਂ ਨਾਲ ਖਰਾਬ ਕੀਤੇ ਜੋ ਸਿਰਫ਼ ਤੁਹਾਡੀ ਮਸ਼ੀਨ 'ਤੇ ਹੀ ਸਹੀ ਹਨ। ਇੱਕ ਸਾਥੀ repo ਨੂੰ ਕਲੋਨ ਕਰਦਾ ਹੈ, $AGENT_HOME ਨੂੰ ਆਪਣੇ ਫਾਈਲਸਿਸਟਮ ਵੱਲ ਮੋੜਦਾ ਹੈ, ਅਤੇ ਆਪਣਾ ਡੇਟਾ ingests ਕਰਦਾ ਹੈ। ਤੁਹਾਡੀ CI pipeline ਹਰ ਵਾਤਾਵਰਣ ਲਈ ਕੰਫਿਗਸ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੇ ਬਿਨਾਂ ਇੱਕ ਨਵਾਂ agent ਚਲਾ ਸਕਦੀ ਹੈ, ਇੱਕ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰ ਸਕਦੀ ਹੈ, ਅਤੇ ਵਿਵਹਾਰ ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦੀ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ agent ਨੂੰ systemd service ਵਜੋਂ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਵੇਰੀਏਬਲ ਨੂੰ service unit ਵਿੱਚ ਜੋੜੋ। ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ containerize ਕਰਦੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ ਆਪਣੇ Dockerfile ਜਾਂ compose file ਵਿੱਚ ਪਾਸ ਕਰੋ। ਜੇਕਰ ਤੁਸੀਂ ਕਈ shells ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਸਨੂੰ ਆਪਣੀ .bashrc ਜਾਂ .zshrc ਵਿੱਚ ਪਾ ਦਿਓ ਤਾਂ ਜੋ ਇਹ ਬਣਿਆ ਰਹੇ। ਸੈੱਟਅੱਪ ਜਾਣਬੁੱਝ ਕੇ ਬੋਰਿੰਗ ਰੱਖਿਆ ਗਿਆ ਹੈ ਕਿਉਂਕਿ ਇਨਫਰਾਸ

ਵਰਜ਼ਨ 0.0.2 ਇਹਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਵੱਖ-ਵੱਖ ਸਿਲੋਜ਼ (silos) ਵਜੋਂ ਨਹੀਂ ਦੇਖਦਾ। ਇਸ ਦੀ ਬਜਾਏ, ਇਹ ਵਰਕਿੰਗ ਮੈਮੋਰੀ ਵਿੱਚ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਤਿੰਨਾਂ ਨੂੰ ਇੱਕੋ ਸਮਰੀਜ਼ੇਸ਼ਨ (summarization) ਲੇਅਰ ਰਾਹੀਂ ਭੇਜਦਾ ਹੈ। ਇਹ ਲੇਅਰ ਦਾਅਵਿਆਂ, ਪ੍ਰਕਿਰਿਆਵਾਂ, ਡੇਟਾ ਪੁਆਇੰਟਾਂ ਅਤੇ ਰਿਸ਼ਤਿਆਂ ਨੂੰ ਕੱਢਦੀ ਹੈ। ਇਹ ਉਸ ਸ਼ੋਰ (noise) ਨੂੰ ਰੱਦ ਕਰ ਦਿੰਦੀ ਹੈ ਜਿਸ ਨੂੰ ਇਨਸਾਨ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਦਿੰਦੇ ਹਨ।

ਸਮਰੀਜ਼ੇਸ਼ਨ (Summarization) ਇੱਕ ਸਕੈਲਿੰਗ ਰਣਨੀਤੀ ਕਿਉਂ ਹੈ

ਸਮਰੀਜ਼ੇਸ਼ਨ ਨੂੰ ਇੱਕ ਲਗਜ਼ਰੀ ਫੀਚਰ ਵਜੋਂ ਦੇਖਣ ਦਾ ਰੁਝਾਨ ਹੈ, ਕੁਝ ਅਜਿਹਾ ਜੋ ਹੋਵੇ ਤਾਂ ਚੰਗਾ ਹੈ ਪਰ ਜ਼ਰੂਰੀ ਨਹੀਂ। ਇਹ ਗਲਤ ਹੈ। ਇੱਕ ਲੈਂਗੂਏਜ-ਮਾਡਲ ਏਜੰਟ ਲਈ, ਸਮਰੀਜ਼ੇਸ਼ਨ ਇੱਕ ਸਕੈਲਿੰਗ ਲੋੜ ਹੈ।

ਕੰਟੈਕਸਟ ਵਿੰਡੋਜ਼ (Context windows) ਦੀਆਂ ਸੀਮਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਰੀਟ੍ਰੀਵਲ ਬਜਟਾਂ (Retrieval budgets) ਦੀਆਂ ਲਾਗਤਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਕੁਕੀ ਬੈਨਰ ਜਾਂ ਵੀਡੀਓ ਸਪਾਂਸਰ ਰੀਡ 'ਤੇ ਖਰਚਿਆ ਗਿਆ ਹਰ ਟੋਕਨ ਉਹ ਟੋਕਨ ਹੈ ਜੋ ਤੁਸੀਂ ਤਰਕ (reasoning) 'ਤੇ ਖਰਚ ਨਹੀਂ ਕਰ ਸਕਦੇ। ਜਦੋਂ ਤੁਹਾਡਾ ਏਜੰਟ ਇੱਕ ਜਵਾਬ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਲੇ-ਦੁਆਲੇ ਜ਼ਿਆਦਾ ਟੈਕਸਟ ਹੋਣ ਨਾਲ ਸਮਾਰਟ ਨਹੀਂ ਬਣਦਾ। ਇਹ ਆਲੇ-ਦੁਆਲੇ ਸਹੀ ਟੈਕਸਟ ਹੋਣ ਨਾਲ ਸਮਾਰਟ ਬਣਦਾ ਹੈ।

ਇੰਜੈਸਸ਼ਨ (ingestion) ਸਮੇਂ ਸ਼ੋਰ ਨੂੰ ਹਟਾ ਕੇ, ਸਿਸਟਮ ਸਿਗਨਲ ਨੂੰ ਕੰਪਰੈੱਸ ਕਰਦਾ ਹੈ। ਤੁਹਾਡਾ ਏਜੰਟ ਉਸੇ ਕੰਟੈਕਸਟ ਬਜਟ ਦੇ ਅੰਦਰ ਸਰੋਤਾਂ ਦੇ ਇੱਕ ਵਿਸ਼ਾਲ ਸਮੂਹ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ। ਦਸ ਨਿਖਾਰੇ ਹੋਏ (distilled) ਦਸਤਾਵੇਜ਼ ਉੱਥੇ ਆ ਸਕਦੇ ਹਨ ਜਿੱਥੇ ਪਹਿਲਾਂ ਦੋ ਕੱਚੇ (raw) ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਮੁਸ਼ਕਲ ਆਉਂਦੀ ਸੀ। ਇਹੀ ਘਣਤਾ (density) ਏਜੰਟ ਨੂੰ ਪੰਜ ਸਰੋਤਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵਾਲੇ ਇੱਕ ਟੌਏ ਪ੍ਰੋਟੋਟਾਈਪ ਤੋਂ ਲੈ ਕੇ ਸੈਂਕੜੇ ਸਰੋਤਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵਾਲੇ ਪ੍ਰੋਡਕਸ਼ਨ ਸਿਸਟਮ ਤੱਕ ਸਕੈਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਮੈਮੋਰੀ ਫੁੱਟਪ੍ਰਿੰਟ ਕੰਟਰੋਲ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ। ਰੀਟ੍ਰੀਵਲ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਅਣਨਾਟਕ ਓਵਰਲੈਪ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ। ਟੋਕਨ ਦੀ ਲਾਗਤ ਘਟ ਜਾਂਦੀ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਬੋਇਲਰਪਲੇਟ (boilerplate) ਨੂੰ ਐਂਬੈਡ ਅਤੇ ਕੁਐਰੀ ਕਰਨ ਲਈ ਭੁਗਤਾਨ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹੋ।

ਇਹ ਕਿਸੇ ਅਗਰੈਸਿਵ ਲੌਸੀ ਕੰਪਰੈਸ਼ਨ (lossy compression) ਬਾਰੇ ਨਹੀਂ ਹੈ ਜੋ ਸੂਖਮਤਾਵਾਂ (nuance) ਨੂੰ ਸੁੱਟ ਦਿੰਦਾ ਹੈ। ਇਹ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਕੋਡ ਕੀਤੇ ਸੰਪਾਦਕੀ ਫੈਸਲੇ (editorial judgment) ਬਾਰੇ ਹੈ। ਸਾਰ (summary) ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਨਾਮਿਤ ਇਕਾਈਆਂ (named entities), ਕਾਰਨ-ਪ੍ਰਭਾਵ ਦੇ ਲਿੰਕਾਂ ਅਤੇ ਨਿਰਦੇਸ਼ਕ ਕਦਮਾਂ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ। ਇਹ ਫਾਰਮੈਟਿੰਗ ਦੇ ਕੂੜੇ ਅਤੇ ਗੱਲਬਾਤ ਦੇ ਵਾਧੂ ਹਿੱਸੇ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ।

ਸ਼ੁਰੂਆਤ ਕਰਨਾ

ਸੈੱਟਅੱਪ ਜਾਣਬੁੱਝ ਕੇ ਨਿਮਾਣਾ ਰੱਖਿਆ ਗਿਆ ਹੈ ਕਿਉਂਕਿ ਸਿਸਟਮ ਦਾ ਮਕਸਦ ਤੁਹਾਡੇ ਰਸਤੇ ਵਿੱਚ ਨਾ ਆਉਣਾ ਹੈ।

ਆਪਣਾ ਟਰਮੀਨਲ ਖੋਲ੍ਹੋ ਅਤੇ ਰੂਟ ਪਾਥ (root path) ਸੈੱਟ ਕਰੋ:

export AGENT_HOME=/your/path

ਇਸ ਲਾਈਨ ਨੂੰ ਆਪਣੇ ਸ਼ੈੱਲ ਪ੍ਰੋਫਾਈਲ (shell profile) ਵਿੱਚ ਜੋੜ ਕੇ ਇਸਨੂੰ ਪੱਕਾ ਬਣਾਓ, ਜਾਂ ਇਸਨੂੰ ਕਿਸੇ ਵੀ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਲੇਅਰ (orchestration layer) ਵਿੱਚ ਪਾ ਦਿਓ ਜੋ ਤੁਹਾਡੇ ਏਜੰਟ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ। ਹੇਠਾਂ ਡਾਇਰੈਕਟਰੀ ਢਾਂਚੇ ਨੂੰ ਇਕਸਾਰ ਰੱਖੋ। ਏਜੰਟ ਉਮੀਦ ਕਰਦਾ ਹੈ ਕਿ ਉਸਦੇ ਫੋਲਡਰ—ਚਾਹੇ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ knowledge/, memory/, summaries/, ਜਾਂ ਕੁਝ ਹੋਰ ਨਾਮ ਦਿਓ—ਉਸ ਰੂਟ ਦੇ ਸਾਪੇਖ ਵਿੱਚ ਹੋਣ। ਇੱਕ ਵਾਰ ਵੇਰੀਏਬਲ ਲਾਈਵ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਏਜੰਟ ਨੂੰ ਆਪਣੇ ਵੈੱਬ ਪੇਜਾਂ, ਟ੍ਰਾਂਸਕ੍ਰਿਪਟਾਂ ਅਤੇ ਲੇਖਾਂ ਵੱਲ ਮੋੜ ਦਿਓ। ਇੰਜੈਸਸ਼ਨ ਅਤੇ ਸਮਰੀਜ਼ੇਸ਼ਨ ਪਾਈਪਲਾਈਨ ਬਾਕੀ ਦਾ ਕੰਮ ਸੰਭਾਲ ਲੈਂਦੀ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਪੁਰਾਣੇ ਵਰਜ਼ਨ ਤੋਂ ਮਾਈਗ੍ਰੇਟ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਵੀ ਉਨੀ ਹੀ ਸਰਲ ਹੈ। ਆਪਣੇ ਮੌਜੂਦਾ ਡੇਟਾ ਨੂੰ ਨਵੇਂ $AGENT_HOME ਹਾਇਰਾਰਕੀ ਵਿੱਚ ਮੂਵ ਕਰੋ, ਵੇਰੀਏਬਲ ਨੂੰ ਅਪਡੇਟ ਕਰੋ, ਅਤੇ ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਏਜੰਟ ਪਾਥਾਂ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਹੱਲ (resolve) ਕਰਦਾ ਹੈ। ਕੋਈ ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟ ਨਹੀਂ। ਕੋਈ ਡੇਟਾਬੇਸ ਸਕੀਮਾ ਬੰਪ ਨਹੀਂ। ਡਿਸਕ 'ਤੇ ਏਜੰਟ ਕਿੱਥੇ ਰਹਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਬੱਸ ਇੱਕੋ ਇੱਕ ਸੱਚ ਦਾ ਸਰੋਤ (single source of truth)।

ਅਸਲ ਸਿੱਖਿਆ

ਬਿਹਤਰ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ (management) ਦਾ ਮਤਲਬ ਜ਼ਿਆਦਾ ਡੇਟਾ ਇਕੱਠਾ ਕਰਨਾ ਨਹੀਂ ਹੈ। ਇਹ ਉਸ ਡੇਟਾ ਨੂੰ ਸੰਭਾਲਣ (curating) ਬਾਰੇ ਹੈ ਜੋ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਹੈ। ਵਰਜ਼ਨ 0.0.2 ਪੋਰਟੇਬਿਲਟੀ ਅਤੇ ਸਮਰੀਜ਼ੇਸ਼ਨ ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਸੋਚਣ ਵਾਲੀਆਂ ਚੀਜ਼ਾਂ ਦੀ ਬਜਾਏ ਪ੍ਰਮੁੱਖ ਚਿੰਤਾਵਾਂ ਵਜੋਂ ਦੇਖਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਤੋੜੇ ਬਿਨਾਂ ਆਪਣਾ ਏਜੰਟ ਮਸ਼ੀਨਾਂ ਵਿਚਕਾਰ ਲਿਜਾਣ ਦੀ ਆਜ਼ਾਦੀ ਮਿਲਦੀ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਅਜਿਹੇ ਕੰਟੈਕਸਟ ਵਿੰਡੋ ਦੀ ਕੁਸ਼ਲਤਾ ਮਿਲਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸਲ ਵਿੱਚ ਕੰਟੈਕਸਟ ਹੁੰਦਾ ਹੈ।

ਆਪਣੀ ਹੋਮ ਡਾਇਰੈਕਟਰੀ ਸੈੱਟ ਕਰੋ। ਏਜੰਟ ਨੂੰ ਅਸਲ ਸਰੋਤ ਦਿਓ। ਸਿਸਟਮ ਨੂੰ ਫਾਲਤੂ ਚੀਜ਼ਾਂ ਹਟਾਉਣ ਦਿਓ। ਤੁਸੀਂ ਪਾਥ ਗਲਤੀਆਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਵਿੱਚ ਘੱਟ ਸਮਾਂ ਅਤੇ ਸ਼ੋਰ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਵਿੱਚ ਘੱਟ ਪੈਸਾ ਖਰਚੋਗੇ, ਅਤੇ ਉਸ ਚੀਜ਼ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਿੱਚ ਜ਼ਿਆਦਾ ਸਮਾਂ ਬਿਤਾਓ ਜੋ ਏਜੰਟ ਨੇ ਅਸਲ ਵਿੱਚ ਸਿੱਖਿਆ ਹੈ।

ਸਰੋਤ: https://dev.to/mage0535/thinking-1-analyze-the-request-12go

ਕਮਿਊਨਿਟੀ: https://t.me/GyaanSetuAi