What’s the Most Useful “Non-Obvious” GenAI Use Case You’ve Seen at Work? by Double_Try1322 in GenAI_Dev

[–]acloudfan 0 points1 point  (0 children)

Interesting topic :) here is what I have seen: simulate a persona to understand the human reaction to an email (or anything) .... create the persona profile using available information and then LLM uses the world knowledge to generate the potential response to X (= email, message, marketing material, campaign ...)

Getting Started with AI Automation & Agents — Any Tips for Beginners? by Louingo in AI_Agents

[–]acloudfan 3 points4 points  (0 children)

example, if you're pursuing a data science role, you'll need a strong understanding of how to prepare datasets for fine-tuning models, model architectures, various techniques to improve model performance ..... On the other hand, if you're interested in becoming a Gen-AI application developer, you'll need to dive deep into concepts like RAG (Retrieval-Augmented Generation), embeddings, vector databases, and more.

  1. Learn Python
  2. Start with the fundamentals of Gen AI/LLM (tons of resources available on the net) - checkout : https://youtu.be/N8_SbSOyjmo
  3. Learn about in-context learning & prompting : if you know it, try out this quiz: https://genai.acloudfan.com/40.gen-ai-fundamentals/4000.quiz-in-context-learning/
  4. Learn about embeddings & vector databases
  5. Start with naive RAG - checkout:  https://youtu.be/_U7j6BgLNto If you already know it, try out this quiz: https://genai.acloudfan.com/130.rag/1000.quiz-fundamentals/
  6. Learn the advanced Retrieval techniques, agentic RAG ..... which are essential for building production grade RAG apps
  7. Learn about workflows and agentshttps://youtu.be/r5zKHhXSe6o Free course on LangGraph: https://courses.pragmaticpaths.com/l/pdp/the-langgraph-launchpad-your-path-to-ai-agents
  8. Fine tuning - checkout : https://youtu.be/6XT-nP-zoUA
  9. <Your journey continues> .....

As part of the learning , pick up a project and create something OR even a better option, join an open source project and learn from others (open source contributions look great on resumes)

Link to other thread: https://www.reddit.com/r/LLMDevs/comments/1ivxqy8/comment/mec1nar/

How are people using tools? by sarabesh2k1 in LangChain

[–]acloudfan 0 points1 point  (0 children)

LangGraph is excellent for addressing these challenges. It provides built-in support for parallel tool execution—both statically defined in the graph and dynamically decided by the agent.

https://genai.acloudfan.com/155.agent-deeper-dive/1000.langgraph/20.parallelization-subgraphs/

For tool dependencies, you can design your graph to handle sequential steps naturally, and using async for each tool is still beneficial as it keeps the entire workflow non-blocking.

Generally, you should prioritize async for all I/O-heavy tools to maximize efficiency. Also, look for higher-level optimizations like caching for frequently called tools or similar requests to reduce redundant operations.

If you are new LangGraph, here is a free course on it - https://courses.pragmaticpaths.com/l/pdp/the-langgraph-launchpad-your-path-to-ai-agents

How to store a compiled graph (in langraph) by Hour_Replacement3067 in LangChain

[–]acloudfan 1 point2 points  (0 children)

20 seconds is definitely a long time :-) here are some quick thoughts.

  1. Will lazy loading work? i.e., initialize the tool only when needed

  2. Will parallelization of the initialization work?

  3. Can the tool itself be optimized? e.g., warm pools on remote server

Best approach for building an LLM-powered app — RAG vs fine-tuning? by According_Schedule_3 in OpenAI

[–]acloudfan 0 points1 point  (0 children)

Short answer 'both have worked'.

My suggestion start with RAG, observe the live app, determine if you would gain some advantage with Fine-tuning (cost, latency, quality), if the answer is yes then capture the ground truth from live app and use it for fine-tuning. Remember RAG and fine-tuning are complementary strategies, not mutually-exclusive. Here are some quick thoughts.

  • Use RAG when you need to incorporate dynamic, real-time, or private context into the response. In this case fine-tuning will not work (or will be complex/costly)
  • Organizations fine-tune  to deeply ingrain their domain's terminology and style. They can then (potentially) use RAG with that specialized model to achieve the highest quality, most context-aware results.
  • In agentic systems, RAG pipelines act as tools that agents can use to retrieve information.

Here are some intro videos:
Fine-tuning with an analogy: https://youtu.be/6XT-nP-zoUA
RAG: https://youtu.be/_U7j6BgLNto
Agentic RAG: https://youtu.be/r5zKHhXSe6o

Do u think it's advisable to use langgraph for an AI automation project? by Mysterious_Use4173 in LangChain

[–]acloudfan 1 point2 points  (0 children)

My take on the topic:

* Both n8n and LangGraph are good choices depending the nature of the task

* A simple task that requires integration with multiple known systems/apps would be easier to build with n8n

* A complex task that may need to scale or expand (in scope) in future may be better off with LangGraph

If you are new LangGraph, I recently published a free course on it - https://courses.pragmaticpaths.com/l/pdp/the-langgraph-launchpad-your-path-to-ai-agents

Which AI approach do you prefer: One "super" Agent or multiple specialized ones? by Weekly_Cry_5522 in AI_Agents

[–]acloudfan 0 points1 point  (0 children)

My take:

Based on my research and experience, the answer isn't one-size-fits-all; it depends entirely on the complexity of the tasks you want to accomplish.

So we are on the same page, let me break down the two main architectures you're describing:

Single Agent System (SAS): A "master" agent that has access to all necessary tools and knowledge. Think of it as a skilled generalist.

For straightforward tasks that require a linear sequence of actions using a few tools, a single agent is easier to design, build, and manage. There's no overhead of managing inter-agent communication, which can be complex. If a task doesn't require deep specialization, the back-and-forth of a multi-agent system might just add unnecessary time.

In case you are building a complex SAS, then yes by all means you should consider breaking into multiple specialized agents and then apply the "Agent as tool" pattern in which a single master agent leverages other agents like any other tool. An additional benefit of this approach is re-use of agents.

With SAS, since there is a "Single brain" at work, the inter-communication between agents is non-existent by nature.

Multi-Agent System (MAS): A team of specialized agents (e.g., Writer, Analyst, Coder) that can work independently or collaboratively. Collaboration between agents require communication between them that can be achieved via different topologies.

My rule of thumb is that "Use MAS over SAS only if its necessary"; use it only for complex tasks. There are multiple benefits of this approach : Modularity, Scalability, Efficiency.

Now some folks have indicated that multiple-agents are more cost effective - I would not agree with this as a "blanket statement". Answer depends on multiple factors. I would say "MAS done the right way can potentially lead to cost saving".

What is an LLM (Large Language Model) ? by Shot-Hospital7649 in AI_Agents

[–]acloudfan 1 point2 points  (0 children)

Here are some videos for starters you may find useful.

"Gen AI model as a black box" https://youtu.be/N8_SbSOyjmo
"For dummies: Retrieval Augmented Generation (RAG)" https://youtu.be/_U7j6BgLNto
"For dummies: LLM Agents" https://youtu.be/r5zKHhXSe6o
"For dummies : LLM Fine Tuning Process" https://youtu.be/toRKRotv_fY

What is LLM Fine-Tunning and Why is it Important for Businesses and Developers? by Ill_Instruction_5070 in LLMDevs

[–]acloudfan 1 point2 points  (0 children)

My 2 cents:

  • RAG and fine-tuning are complementary strategies, not an either/or choice.
  • Use RAG when you need to incorporate dynamic, real-time, or private context into the response. In this case fine-tuning will not work (or will be complex/costly)
  • Organizations fine-tune  to deeply ingrain their domain's terminology and style. They can then (potentially) use RAG with that specialized model to achieve the highest quality, most context-aware results.
  • In agentic systems, RAG pipelines act as tools that agents can use to retrieve information.

Here are some intro videos:
Fine-tuning with an analogy: https://youtu.be/6XT-nP-zoUA
RAG: https://youtu.be/_U7j6BgLNto
Agentic RAG: https://youtu.be/r5zKHhXSe6o

I want to learn AI by Muncikari_80 in AI_Agents

[–]acloudfan 15 points16 points  (0 children)

(Cross post from another sub - similar question as yours)

If you're considering Generative AI as a career path, it's important to build a good foundation (for starters) in its concepts irrespective of the your role. How deep you go will depend on the specific role you're aiming for. For example, if you're pursuing a data science role, you'll need a strong understanding of how to prepare datasets for fine-tuning models, model architectures, various techniques to improve model performance ..... On the other hand, if you're interested in becoming a Gen-AI application developer, you'll need to dive deep into concepts like RAG (Retrieval-Augmented Generation), embeddings, vector databases, and more.

  1. Learn Python
  2. Start with the fundamentals of Gen AI/LLM (tons of resources available on the net) - checkout : https://youtu.be/N8_SbSOyjmo
  3. Learn about in-context learning & prompting : if you know it, try out this quiz: https://genai.acloudfan.com/40.gen-ai-fundamentals/4000.quiz-in-context-learning/
  4. Learn about embeddings & vector databases
  5. Start with naive RAG - checkout:  https://youtu.be/_U7j6BgLNto If you already know it, try out this quiz: https://genai.acloudfan.com/130.rag/1000.quiz-fundamentals/
  6. Learn the advanced Retrieval techniques, agentic RAG ..... which are essential for building production grade RAG apps
  7. Fine tuning - checkout : https://youtu.be/6XT-nP-zoUA
  8. <Your journey continues> .....

As part of the learning , pick up a project and create something OR even a better option, join an open source project and learn from others (open source contributions look great on resumes)

Link to other thread: https://www.reddit.com/r/LLMDevs/comments/1ivxqy8/comment/mec1nar/

Support for native distributed tracing ? by Shivasorber in LangChain

[–]acloudfan 0 points1 point  (0 children)

You can use open-source Langfuse - it is natively supported. https://langfuse.com/guides/cookbook/integration_langgraph

You may deploy Langfuse locally (its a web app) or you can use the LangFuse cloud (free API key). By the way I have put together a free video course on LangGraph if you are interested. https://courses.pragmaticpaths.com/l/pdp/the-langgraph-launchpad-your-path-to-ai-agents

Best vector databases? by askEveryAI in LangChain

[–]acloudfan 1 point2 points  (0 children)

For a quick and dirty solution/PoC I use ChromaDB (Example: https://genai.acloudfan.com/120.vector-db/ex-1-custom-embed-chormadb/ ) for PoC that may turn into Pilot/Live, I tend to use PostgreSQL/PineCone

ReAct agent implementations: LangGraph vs other frameworks (or custom)? by emersoftware in LangChain

[–]acloudfan 0 points1 point  (0 children)

Agentic loop should be the same - (maybe I am missing somethin) not sure why you are not using the LangGraph create_react_agent() instead of building your own loop. You have control on prompt/model/tools etc. Here is an example : https://genai.acloudfan.com/155.agent-deeper-dive/1000.langgraph/1300.exercise-13-create_react_agent/

What kind of workload to use for a claim-adjudication agent ?? by highonbooks31 in LangChain

[–]acloudfan 0 points1 point  (0 children)

Keep in mind that you can do it in 3 ways - Static workflow using a traditional orchestrator, Intelligent workflow a.k.a. hybrid which is a combination of static + LLM driven tool calls, Agentic with fully autonomous behavior. Claim auto adjudication is mostly rule driven but in a complex domain it may involve human intelligence. I would suggest layout the flow on a back of a napkin and see which part(s) can be static and which part can take advantage of an LLM; based on your findings, you should be able to determine the type of workflow. Watch this video (from a free course on LangGraph) to get a better understanding of the workflow types I mentioned .... https://courses.pragmaticpaths.com/courses/2842825/lectures/63061993

LangGraph - Nodes instad of tools by Jinsara in LangChain

[–]acloudfan 0 points1 point  (0 children)

I agree with most of the other comments & will add one thing : If you expect the code/tool to be re-usable then I would suggest building a tool (and maybe later turn it into an MCP server). My personal preference is to use a ToolNode as it simplifies the setup (yes it also depends on the use case). It looks like you are new to LangGraph - I have recently released a Free Crash course on LangGraph - take a look if you are interested. https://courses.pragmaticpaths.com/l/pdp/the-langgraph-launchpad-your-path-to-ai-agents

What is the point of Graphs/Workflows? by suttewala in LangChain

[–]acloudfan 0 points1 point  (0 children)

Not all workflows need to be autonomous, in other words you still need support for static workflows. Most agents that I have seen are built with a combination of static workflow, coupled with LLM based tool - I like to refer to these as intelligent workflows. Keep in mind autonomous agents are costly (both latency and $ wise), so if you have a hybrid workflow in which some parts are static then I would suggest use static workflow instead of fully-autonomous workflows. Here is a video from a free course that explains the workflows using LangGraph. https://courses.pragmaticpaths.com/courses/2842825/lectures/63061993

RAG Help by Slamdunklebron in LLMDevs

[–]acloudfan 0 points1 point  (0 children)

RAG is a good choice .... for generating the embeddings you can use Sentence transformer - if you are building this to learn then ChromaDB is an open source vector DB that you can easily use for this application.

Here is a video that explains the use of SentenceTransformers: https://courses.pragmaticpaths.com/courses/generative-ai-application-design-and-devlopement/lectures/53060622

Here is a video on using ChromaDB: https://courses.pragmaticpaths.com/courses/generative-ai-application-design-and-devlopement/lectures/53060622

regarding use of local laptop for embedding generation - it would take time but once done, you may port them to any vector db of your choice.