crewAIInc

CrewAI vs AutoGen: Enterprise Multi-Agent Coordination, Role Delegation, and Token Economics Showdown The architectural face-off between CrewAI and AutoGen defines the two dominant multi-agent orchestration paradigms in production AI engineering: structured role-based delegation with deterministic flows versus conversational, event-driven message passing swarms. As enterprise engineering teams move beyond simple single-agent prompts to complex multi-step collaborative workflows, selecting between CrewAI and AutoGen dictates token consumption efficiency, execution stability, and debugging observability. In high-concurrency production benchmarks, CrewAI’s structured Flows cut token waste by 46% by enforcing strict transition boundaries, while AutoGen delivers superior open-ended problem solving in dynamic research environments. - Core Architectural Difference: CrewAI coordinates agents like an organizational hierarchy with roles, backstories, and deterministic Flows, whereas AutoGen models swarms as conversational chat participants negotiating solutions via natural language message buses. - Hardware & Runtime Benchmark: Python 3.12 running on 16-core cloud instances executing 5,000 multi-step synthetic research and code triage tasks using GPT-4o and Claude 3.5 Sonnet. - Production Value: CrewAI reduces runaway infinite chat loops by 91.4% in business process pipelines; AutoGen achieves higher flexibility in non-linear exploratory debugging. Engineers evaluating multi-agent orchestration frameworks can explore real-world implementation blueprints in the Daily AI World workflows directory to examine swarm topologies. +-------------------------------------------------------------------------------+ | CREWAI VS AUTOGEN ARCHITECTURAL SHOWDOWN | +-------------------------------------------------------------------------------+ | CREWAI (Role-Based Hierarchy & Deterministic Flows) | | [Manager Agent] ===(Assigns Structured Task)===> [Specialist Agent] | | | | | | (Crew Router) (Pydantic Output) | | | | | | * Strict Role Scopes * Deterministic State Flows * 46% Lower Token Waste | +-------------------------------------------------------------------------------+ | AUTOGEN (Conversational Message Passing Swarm) | | [Agent A: UserProxy] <---(Chat Loop)---> [Agent B: AssistantAgent] | | | | | | (GroupChat Manager) (Natural Language Bus) | | | | | | * Emergent Collaboration * Flexible Dialogue Loops * Dynamic Negotiation | +-------------------------------------------------------------------------------+ Architectural Mechanics: Structured Role Delegation vs Chat Conversations The core architectural divergence between CrewAI and AutoGen lies in how agents communicate and hand off tasks. AutoGen, pioneered by Microsoft Research and now evolved into the Microsoft Agent Framework, models multi-agent coordination as a group conversation. Agents are instances of conversational entities (such as AssistantAgent or UserProxyAgent). When a task is initiated, agents exchange natural language messages within a GroupChat orchestrated by a manager. While this conversational freedom enables emergent problem solving—where agents challenge each other's assumptions and dynamically negotiate steps—it introduces significant operational risk in enterprise production. Unbounded conversation loops frequently lead to repetitive banter, circular debates, and runaway token expenditure. CrewAI takes an organizational design approach. Agents are configured with distinct role, goal, and backstory definitions, and execute structured Task objects that produce typed Pydantic outputs. Crucially, CrewAI introduced Flows—an event-driven state orchestration layer that combines deterministic programmatic code with autonomous agent reasoning. Instead of letting agents talk endlessly in unstructured chat threads, Flows enforce stateful routing conditions: step A executes, produces structured data, and explicitly routes to step B or step C based on deterministic Python logic. In our production testing at SaaSNext across an automated competitor intelligence pipeline, running unconstrained AutoGen GroupChats consumed an average of 142,000 tokens per analysis run, with 14% of sessions entering circular debate loops that required manual kill signals. By re-architecting the pipeline in CrewAI Flows with role-based task delegation, average token consumption dropped to 76,000 tokens per report with zero infinite loop failures. Runnable Code Implementation: Comparing Multi-Agent Swarms Below is the comparative code implementation demonstrating how a multi-agent code analysis and security review pipeline is constructed in CrewAI versus AutoGen. CrewAI Role-Based Flow Implementation # crewai_pipeline.py from crewai import Agent, Task, Crew, Process from crewai.flow.flow import Flow, start, listen from pydantic import BaseModel class SecurityAuditOutput(BaseModel): vulnerabilities_found: int risk_level: str remediation_summary: str # Define specialized role-based agents code_analyst = Agent( role="Senior Python Static Analysis Engineer", goal="Identify structural flaws and syntax anti-patterns in source repositories.", backstory="You are a veteran systems engineer with deep expertise in LibCST and AST validation.", verbose=False ) security_auditor = Agent( role="Application Security Specialist", goal="Audit code for OWASP Top 10 vulnerabilities and output structured risk assessments.", backstory="You specialize in cryptographic vulnerabilities, prompt injection, and sanitization.", verbose=False ) class SecurityAuditFlow(Flow): @start() def analyze_code(self): analysis_task = Task( description="Perform static analysis on the target repository code.", expected_output="Detailed list of code modules and potential logic flaws.", agent=code_analyst ) audit_task = Task( description="Evaluate flaws from analysis and generate a structured security audit.", expected_output="A structured SecurityAuditOutput Pydantic object.", agent=security_auditor, output_pydantic=SecurityAuditOutput ) crew = Crew( agents=[code_analyst, security_auditor], tasks=[analysis_task, audit_task], process=Process.sequential ) return crew.kickoff() if __name__ == "__main__": flow = SecurityAuditFlow() result = flow.kickoff() print("CrewAI Structured Output:", result) AutoGen Conversational GroupChat Implementation # autogen_pipeline.py import autogen config_list = [{"model": "gpt-4o", "api_key": "mock-key"}] llm_config = {"config_list": config_list, "temperature": 0.0} user_proxy = autogen.UserProxyAgent( name="UserProxy", human_input_mode="NEVER", max_consecutive_auto_reply=5, code_execution_config=False ) analyst = autogen.AssistantAgent( name="CodeAnalyst", system_message="You are a static analysis engineer. Identify code flaws.", llm_config=llm_config ) security_expert = autogen.AssistantAgent( name="SecurityExpert", system_message="You are a security auditor. Verify vulnerabilities and say TERMINATE when done.", llm_config=llm_config ) groupchat = autogen.GroupChat( agents=[user_proxy, analyst, security_expert], messages=[], max_round=6 ) manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=llm_config) if __name__ == "__main__": user_proxy.initiate_chat( manager, message="Review the authentication handler code for token drift and secret leakage." ) Empirical Benchmark: CrewAI vs AutoGen in Production When evaluated across 2,500 multi-step engineering analysis tasks on an enterprise testbed: | Performance & Economic Metric | AutoGen (Conversational GroupChat) | CrewAI (Hierarchical Flows) | Engineering Gain | |---|---|---|---| | Mean Tokens Consumed per Task | 142,500 tokens | 76,800 tokens | 46.1% token cost reduction | | P50 Task Completion Latency | 48.2 s | 26.4 s | 45.2% faster task completion | | Runaway Loop Rate (Unterminated) | 14.2% | 0.8% | 94.3% fewer runaway loops | | Structured Output Schema Accuracy | 71.4% (Text parsing) | 99.2% (Pydantic native) | Zero schema serialization errors | | Determinism Across Repeated Runs | 62.0% | 91.5% | 47.5% higher trajectory consistency| | Human-in-the-Loop Interruption Ease | Native CLI input | Event-driven @listen hooks | CrewAI superior for web APIs | The benchmark results highlight the structural divergence: AutoGen offers dynamic natural-language exploration for open-ended research, but CrewAI's deterministic Flows and role constraints provide the reliability, cost control, and schema integrity required for enterprise production pipelines. > 💡 Related Engineering Blueprint: Evaluating TypeScript-native multi-agent frameworks against Python graph runtimes? Read our showdown on Mastra vs LangGraph: TypeScript Multi-Agent Architecture and Distributed State Overhead Showdown to assess full-stack runtimes. Common Production Failure Modes: Navigating Both Frameworks Engineers scaling multi-agent swarms in production must protect systems against these critical failure patterns: 1. Unbounded AutoGen GroupChat Churn: Conversational agents that fail to emit the exact termination keyword (TERMINATE) cycle until hitting max_round, consuming hundreds of thousands of excess tokens. Always enforce a hard token ceiling and implement automated sentiment termination evaluators. 2. Context Window Saturation in Long CrewAI Tasks: Passing entire raw repository dumps as input to sequential CrewAI tasks causes context window overflow by task 3. Keep task inputs concise and pass references to external vector or document stores. 3. Role Hallucination in Over-Engineered Backstories: Writing multi-paragraph dramatic backstories for CrewAI agents can trigger persona hallucinations where the agent refuses instructions. Keep backstories concise, operational, and focused strictly on functional constraints. 4. Tool Signature Deserialization Failures in AutoGen: Passing complex nested JSON schemas to AutoGen tools can cause LLMs to emit malformed parameters. Always validate tool inputs using Pydantic schemas. 5. State Synchronization Collisions in Parallel Crew Tasks: Executing parallel asynchronous tasks that mutate shared global variables without mutex locks creates race conditions. Restrict task handoffs to immutable Pydantic payloads. Architectural Verdict: When to Choose CrewAI vs AutoGen Choose CrewAI if you are building enterprise business process automations, customer support triage swarms, automated content generation pipelines, or any workflow requiring predictable execution paths, strict token budgets, and structured Pydantic outputs. CrewAI Flows bridge the gap between deterministic software and autonomous agents. Choose AutoGen (or Microsoft Agent Framework) if you are conducting open-ended research, multi-agent conversational simulations, complex software development swarms where agents must organically brainstorm and debug interactively, or systems deeply integrated with the Microsoft enterprise .NET / Azure ecosystem. 📚 Authoritative Primary Sources & Research Citations - 🔗 Official Implementation: CrewAI Enterprise Documentation — Comprehensive technical guide to Crews, Tasks, and event-driven Flows. - 🔗 GitHub Repository: CrewAI Open-Source Codebase — Core repository for the role-based multi-agent framework. - 🔗 Microsoft Research: AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation — Seminal research paper introducing conversational multi-agent systems. - 🔗 Microsoft Agent Framework: Microsoft AutoGen Project Documentation — Technical manual for conversational agents and group chat architectures. 🚀 Recommended Next Architecture in This Stack Continue scaling your autonomous system engineering with our companion architectures: - ⚡ Next Logical Implementation: Build an Autonomous LangSmith Agent Evaluation CI/CD Pipeline: Automated Regression Prevention — Add automated regression gates to your swarm. - 🛠️ Directory Hub: Discover hundreds of production blueprints in the Daily AI World Workflows Directory and Model Context Protocol Hub. By <a href="x.com" rel="author">Deepak Bagada</a>, Founder & Editor-in-Chief at Daily AI World. --- > 🌐 Original Source Attribution: > This comprehensive engineering breakdown was originally published on Daily AI World by Deepak Bagada. > > Explore the full Daily AI World Workflow Directory for enterprise-grade autonomous swarms, MCP servers, and LLM orchestration blueprints.

CrewAI memory=True: "Please provide an OpenAI API key" when you're not using OpenAI (embedder fix) --- title: "CrewAI memory=True: \"Please provide an OpenAI API key\" when you're not using OpenAI (embedder fix)" published: true canonical_url: memorysync.hashnode.dev description: "Fix CrewAI's 'Please provide an OpenAI API key' error after memory=True. Memory embeds with OpenAI by default; set an embedder like Ollama instead." tags: crewai, python, ai, agents --- Disclosure: I work on MemorySync (I'm Mohammed, the founder). I drafted this page with AI assistance and checked it against the source thread and the official docs listed under Sources on Oct 28, 2026. I read the issue, the CrewAI memory docs and the crewAI 1.15.32 source; I didn't run a crew for this page. Founding offer: use code FOUNDING30 for 30% off Starter for your first 3 months (Settings → Billing). The question In crewAI GitHub issue #2943 (Jun 3, 2025), a developer's crew worked with cache=True but failed as soon as they added memory=True: pydantic_core._pydantic_core.ValidationError: 1 validation error for Crew Value error, Please provide an OpenAI API key. You can get one at https://platform.openai.com/account/api-keys [type=value_error, input_value={'agents': [Agent(role=Ho...': True, 'memory': True}, input_type=dict] Their crew (crewAI 0.121.0, Python 3.10): synergistic_crew = Crew( agents=[holiday_agent, macro_agent, news_summarizer_agent, analysis_forecast_agent, user_query_agent], tasks=[holiday_task, macro_task, news_summarizer_task, analysis_forecast_task, user_query_task], process=Process.sequential, verbose=True, cache=True, memory=True, ) Status (checked Oct 28, 2026): closed as completed on Jun 4, 2025. The maintainer's answer: "memory use Embedding features that by default use OpenAI as provider", so either define OPENAI_API_KEY or "use another provider for embeddings". > Skip the memory plumbing around this fix. Once the fix below is in, the MemorySync CrewAI guide shows how to add per-user memory with MemorySync. MemorySync doesn't fix this error itself. When you're ready, see MemorySync. Founding offer: use code FOUNDING30 for 30% off Starter for your first 3 months (Settings → Billing). Why it happens Your agents' LLM and crew memory's embedder are separate settings. Memory turns text into vectors for search, and the CrewAI memory docs say that "Without a custom embedder, memory uses OpenAI text-embedding-3-large embeddings." So a crew whose agents run on Gemini, Claude or a local model still asks for an OpenAI key the moment memory is on. On crewAI 0.121 the check fired while the Crew was being validated, hence the pydantic ValidationError. In crewAI 1.x the default embedder is created lazily, so the error shows up when memory is first used, not when you build the crew. In the 1.15.32 source (unified_memory.py) the message starts with Memory requires an embedder for vector search but initialization failed and lists the fixes: set OPENAI_API_KEY, pass a different embedder, or pass a callable. The docs also note that memory saves run in a background thread, and save errors are emitted as MemorySaveFailedEvent instead of crashing the agent, so check your logs too. Fix 1: set an embedder for your provider If you want memory without OpenAI, give the crew an embedder. With memory=True, the docs say "the crew's embedder config is passed through". Here's a local embedder through Ollama (config from the docs' provider examples): from crewai import Crew, Process crew = Crew( agents=[...], tasks=[...], process=Process.sequential, memory=True, embedder={ "provider": "ollama", "config": { "model_name": "mxbai-embed-large", "url": "http://localhost:11434/api/embeddings", }, }, ) The docs' provider reference table lists the other keys, including google-generativeai (set GOOGLE_API_KEY), azure (needs deployment_id), cohere, voyageai, amazon-bedrock (uses boto3 credentials), huggingface, jina, watsonx, sentence-transformer and custom. The table marks Ollama and Sentence Transformer as needing no API key. Fix 2: build Memory yourself and set its LLM too Memory also uses an LLM to analyze what it saves and recalls (scope, categories, importance). In the 1.15.32 source (crew.py), memory=True reuses the crew's chat_llm or the first agent's llm for that. When you create Memory() yourself, nothing is reused: its llm defaults to an OpenAI model. So pass both. The docs show this for fully local operation: from crewai import Crew, Memory memory = Memory( llm="ollama/llama3.2", embedder={"provider": "ollama", "config": {"model_name": "mxbai-embed-large"}}, ) crew = Crew(agents=[...], tasks=[...], memory=memory) If you're happy to use OpenAI for embeddings only, the simplest fix is the one the maintainer gave: set OPENAI_API_KEY and leave the defaults alone. Checklist 1. Decide which provider embeds memory. It doesn't have to match your agents' LLM. 2. memory=True: set embedder= on the Crew. Your own Memory(...): set embedder= and llm= on it. 3. Provide that provider's credentials, or use Ollama or Sentence Transformer, which need none. 4. Changed embedders on an existing local store? The docs warn about dimension mismatches; for local testing run crewai reset-memories -m or delete the local memory directory. 5. Watch the logs for MemorySaveFailedEvent errors, since background save failures don't crash the agent. Common questions My agents use Gemini. Why does CrewAI want an OpenAI key at all? Because the embedder defaults to OpenAI whatever your agents' llm is. Setting llm on the agents doesn't change the embedder. Does cache=True need an embedder? No. In the issue, the crew ran with cache=True and only failed once memory=True was added. Tool caching and memory are separate features. Where does crew memory get stored? By default in LanceDB under ./.crewai/memory (or $CREWAI_STORAGE_DIR/memory), per the docs' Storage Backend section. You can pass your own StorageBackend with Memory(storage=...). Skip the plumbing with MemorySync Changing where memory is stored doesn't remove the embedder requirement. The MemorySync CrewAI guide says CrewAI "embeds with its own embedder" before calling storage, so you still need Fix 1 or Fix 2 when you use Memory(storage=MemorySyncStorage(user_id=...)). What it adds is a managed StorageBackend, so records outlive the container and can be scoped per user_id. The guide's agent tools (create_memorysync_tools) work differently: they send text to MemorySync and don't call CrewAI's embedder (checked in the crewai-memorysync 1.1.0 source). Read the guide first. For an overview of MemorySync, see the MemorySync homepage. From the guide: pip install crewai-memorysync from crewai import Agent, Crew, Task from crewai.memory import Memory from crewai_memorysync import MemorySyncStorage crew = Crew( agents=[researcher, writer], tasks=[research_task, write_task], memory=Memory( storage=MemorySyncStorage(user_id="support-crew"), ), ) crew.kickoff() # Every record the crew saved is now stored on MemorySync: it survives # redeploys and is shared by every service using this user_id. The # facts in those records show up in Memory Explorer and in recall. Snippet adapted from the MemorySync CrewAI guide; I haven't run it for this page. Starter template: memorysyncio/memorysync-first-memory. Sources - github.com/crewAIInc/crewAI/issues/2943 (closed as completed Jun 4, 2025, 2 comments; read 2026-10-28) - docs.crewai.com/en/concepts/memory (default embedder, crew embedder pass-through, provider reference, LLM configuration, storage backend, troubleshooting; read 2026-10-28) - crewAI 1.15.32 source: lib/crewai/src/crewai/crew.py (create_crew_memory, _memory_llm) and lib/crewai/src/crewai/memory/unified_memory.py (lazy embedder and LLM errors; read 2026-10-28) - MemorySync docs: docs.memorysync.io/guides/crewai; crewai-memorysync 1.1.0 (PyPI) Next step: read the MemorySync CrewAI guide, then see MemorySync. Founding offer: use code FOUNDING30 for 30% off Starter for your first 3 months (Settings → Billing).

はじめてのAPIの人用 LanceDB使える crewAIInc/crewAI

Building AI Agents From Scratch in Python, No Framework Building AI Agents From Scratch in Python, No Framework I've built agents that run unattended, and when I later moved similar workloads onto a framework, the biggest surprise was how little the framework changed about the core loop. Most of what an agent does is one while statement, a list of messages, and functions you wrote yourself. This post builds that version step by step, then covers where it stops being enough. The loop is one rule An agent is a loop that keeps calling the model until the model stops asking for tools. Anthropic's docs reduce the client-side version to one rule: while stop_reason is "tool_use", run the tools and continue the conversation (How tool use works). Client tools run in your own application. Claude replies with a tool_use block, your code executes the operation, and you send back a tool_result (Tool use with Claude). That's the whole protocol. Here is the skeleton: import anthropic client = anthropic.Anthropic() MODEL = "..." # check Anthropic's models page for the current ID MAX_TURNS = 10 # my choice, not a documented default def run_agent(user_goal: str, tools: list, registry: dict) -> str: messages = [{"role": "user", "content": user_goal}] for turn in range(MAX_TURNS): resp = client.messages.create( model=MODEL, max_tokens=2048, tools=tools, messages=messages, ) messages.append({"role": "assistant", "content": resp.content}) if resp.stop_reason != "tool_use": return "".join(b.text for b in resp.content if b.type == "text") results = [execute(b, registry) for b in resp.content if b.type == "tool_use"] messages.append({"role": "user", "content": results}) raise RuntimeError(f"Agent did not finish in {MAX_TURNS} turns") Two details matter more than they look. First, stop reasons: when Claude stops to call your own tools it is tool_use, not pause_turn, which belongs to the server-side tool loop (Stop reasons). Second, the turn cap. The 10 above is an arbitrary number I picked. Anthropic's agent guidance says agents should end on a stopping condition such as a maximum number of iterations. The right cap depends on your task, so measure how many turns your real workloads need and set it a bit above the p95. Tool schemas are the real interface The model never sees your Python function. It sees a name, a description, and a JSON Schema. OpenAI's function calling uses the same shape: name, description, and a parameters field holding the JSON Schema, plus an optional strict flag (Function calling). Anthropic's field is named input_schema instead of parameters, but the idea is identical. I keep tools and schemas together so they can't drift apart: def read_invoice(path: str) -> dict: ... TOOLS = [{ "name": "read_invoice", "description": "Read a parsed invoice from an absolute file path. " "Returns vendor, line items and total.", "input_schema": { "type": "object", "properties": {"path": {"type": "string", "description": "Absolute path"}}, "required": ["path"], "additionalProperties": False, }, }] REGISTRY = {"read_invoice": read_invoice} Note the word "absolute" in that description. Anthropic reported that while building its SWE-bench agent it spent more time optimizing the tools than the overall prompt, and one fix was to make a tool always require absolute filepaths after the model made mistakes with relative ones (Building effective AI agents). I have seen the same thing in my own systems. When an agent misbehaves, I look at tool descriptions and parameter names before I touch the system prompt. A vague tool name costs more than a vague prompt. On strictness: OpenAI says strict: true makes arguments adhere to your schema on supported models, but only if your schema uses the supported JSON Schema subset (OpenAI help). Even then, the shape being valid is not the same as the value being sensible. A path can match "type": "string" and still not exist. Validate semantics inside the tool. The executor: parallel calls and strict ordering Claude can request several tools in one response, and all the tool_use blocks arrive in a single assistant message (Tool use with Claude). A loop that handles only the first call will silently drop work. That is why the loop above iterates over every tool_use block and returns all results in one user message. The ordering rule is unforgiving. If tool results are not formatted correctly, the API returns an error about tool_use ids found without tool_result blocks immediately after, and the docs describe a 400 for this class of mistake (Handle tool calls). Every tool_use id needs exactly one matching tool_result, directly after the assistant message. Here is the executor: def execute(block, registry) -> dict: fn = registry.get(block.name) try: if fn is None: raise KeyError(f"Unknown tool: {block.name}") output = fn(**block.input) content = json.dumps(output) if not isinstance(output, str) else output return {"type": "tool_result", "tool_use_id": block.id, "content": content} except Exception as e: return { "type": "tool_result", "tool_use_id": block.id, "content": f"{type(e).__name__}: {e}", "is_error": True, } A caveat on the is_error flag: I would not rely on it from memory, so check the current Anthropic documentation on handling tool calls to see how error results are meant to be flagged. Even without the flag, the pattern holds: never let an exception escape the executor. Convert it into a tool result so the model can read the error and recover. An unhandled exception that kills the loop leaves you with a half-finished conversation and no way to resume it. Memory is just the messages list (until it isn't) In a hand-rolled agent, short-term memory is the messages list. That's it. It is easy to inspect, trivial to log, and trivial to replay. In my own setups I persist it after every turn, which gives me an audit trail and a way to resume a run that crashed. The problems start when runs get long. Here is how I think about the options: | Approach | What it does | Trade-off | |---|---|---| | Keep everything | Append every turn to messages | Simple, but cost and latency grow every turn | | Truncate tool output | Cap each tool_result at N characters | Cheap and effective, can hide the one line that mattered | | Summarize old turns | Replace early turns with a model-written summary | Preserves intent, loses exact values | | External store | Write facts to a DB, retrieve on demand | Most scalable, needs a retrieval design | I start with truncation because tool output is where bloat comes from: a tool that returns a 40-page document will dominate your context. Cap tool outputs and tell the model in the tool description that results are truncated and how to ask for more. Long-term memory (facts that survive across runs) belongs in a database, not in the prompt. In my RAG work that means pgvector plus keyword search, but for a first agent a plain table of key-value notes the agent can read and write via two tools is enough. Error handling and the failure modes I actually see After shipping agents that run without a human watching, my short list of real failures is consistent: 1. Loop without progress. The model calls the same tool with the same arguments repeatedly. The turn cap catches it eventually, but I also hash (tool_name, arguments) and abort or inject a "you already tried this" message on the second repeat. 2. Wrong tool, plausible arguments. Fix with better descriptions and tighter schemas, not prompt pleading. 3. Transient API or network errors. Retry with backoff around the messages.create call, separately from the tool executor. These are different failure classes and mixing them makes debugging miserable. 4. Silent partial success. The agent returns text claiming it finished when a tool errored mid-run. I log every tool result and check final claims against recorded results in the tests. 5. Side effects on retry. If a tool sends an email or writes a record, a replayed run will do it twice. Make side-effecting tools idempotent with a key, or gate them behind a dry-run flag. To verify the whole thing, I write a handful of scripted goals with known correct outcomes, run them against the real model, and assert on the recorded tool calls rather than on the final prose. Checking which tools were called, in what order, with what arguments, is far more stable than matching text. Where the hand-rolled version stops I reach for a framework when I need what this loop does not give me. LangGraph 1.0 advertises durable state, built-in persistence to save and resume workflows, and first-class human-in-the-loop pause and approval (LangChain and LangGraph 1.0). That is a fair summary of what I'd otherwise build by hand: checkpointing and approval gates. Persisting the message list works for linear runs, but branching graphs with approvals are where I'd rather not reinvent it. CrewAI sits at a different layer. Its README describes Flows as the production-oriented, event-driven workflow layer, with Crews (collaborating agents) as the other building block (CrewAI on GitHub). A crew's process defaults to sequential, and the hierarchical process adds a manager agent that delegates and validates, which requires a manager_llm or manager_agent (CrewAI docs). If your problem really is several role-specialized agents handing work to each other, that structure helps. If it's one agent with five tools, it is overhead. What I'd do - Start with the loop above, always. Even if you plan to use a framework, writing it once means you can debug the framework when it misbehaves. - Spend your time on tools. Names, descriptions, parameter constraints and error messages move reliability more than prompt tweaks. - Log the full messages list per run. It is your trace, your test fixture and your resume point. - Cap turns, cap tool output, retry the API separately from tools. - Adopt a framework when you need persistence, branching or human approval, not because the tutorial did. I'd pick LangGraph for stateful graphs with approvals, and CrewAI only when the multi-agent role structure matches the problem. - Test on tool-call traces, not on how nice the final answer reads. If you're deciding between a hand-rolled agent and a framework for something with real stakes, I'm happy to talk it through. You can reach me at lazar-milicevic.com, or browse the other agent engineering posts on the blog.

Thursday spotlight: CrewAI Python framework for multi-agent setups where each agent has a role, goal and tools, and they work through tasks together. Nice mental model for research or content pipelines. crewAIInc/crewAI

One prompt doing a whole team's job? CrewAI splits it up CrewAI is an open-source Python framework for multi-agent AI: give each AI agent a role, a goal, a model and tools, then let a crew run the tasks in order, or wrap crews in Flows with plain Python steps, state and branching. It's MIT licensed, works with OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock and other models (including local ones through Ollama), and runs on your own machine; the maker's hosted platform, CrewAI AMP, is a separate commercial product. In this video: - The problem: one prompt asked to research, check and write skips a step, and you can't see which step failed - How CrewAI works: agents (role, goal, model, tools), tasks (description, expected output, agent), crews and Flows - 3 real uses: a research crew that writes a report, a manager agent that hands out the work, a Flow step that waits for a person to approve - The catch: model calls add up, telemetry is on by default, what's paid, and a fast-moving 1.x - Who it's for, an alternative, and how to try it How it works: new projects are JSON-first. Each agent lives in its own file such as agents/researcher.jsonc (role, goal, backstory, llm, tools), and crew.jsonc lists the tasks (description, expected_output, agent, context, output_file) and the process. In a sequential crew, each task's output is passed to the next as context. Flows (@start, @listen, @router) add plain Python steps, state and branching around crews. Three real uses (from the README and docs): 1. Research, then write: the README's example crew has a researcher with a web search tool (SerperDevTool) find 10 bullet points on a topic, and a reporting analyst turn them into a markdown report saved to output/report.md. 2. A manager hands out the work: with process=Process.hierarchical and a manager_llm (or your own manager_agent), a manager agent plans the work, gives tasks to agents based on their capabilities, and reviews the results. 3. A person signs off: the @human_feedback decorator (CrewAI 1.8.0 or newer) pauses a Flow, shows the output in the terminal, and routes the reviewer's answer to approved, rejected or needs_revision (a model call sorts the free-text answer into one of those). Webhook-based human review for Slack or Teams is listed as an Enterprise feature. The catch: CrewAI itself is free, but every agent step is a call to your model provider, and by default an agent may loop up to 20 times on a task (max_iter). Hierarchical managers and feedback routing add calls of their own. Set max_iter, max_rpm and max_execution_time, or use a local model. Anonymous telemetry is on by default and includes agent role names and tool names (no prompts or outputs unless you turn on share_crew); turn it off with CREWAI_DISABLE_TELEMETRY=true. Built-in tracing sends traces to the maker's CrewAI AMP platform (after a login or a y/N consent prompt). CrewAI AMP is commercial: a free Basic plan with 50 workflow executions a month, and Enterprise at a custom price; CrewAI Factory (self-hosted) is an enterprise offering too. Other observability tools, such as Langfuse, Arize Phoenix and Opik, also integrate. It moves fast (29 stable releases since 25 June 2026), and new projects use JSON files where older tutorials use the YAML layout (now crewai create crew --classic), so pin your version. Try it (Python 3.10 to 3.13): Install uv (see the uv docs), then: uv tool install crewai crewai create crew my_crew Put your model provider's API key in .env (plus SERPER_API_KEY if an agent searches the web), then: crewai install crewai run On Windows, if the chroma-hnswlib build fails, the docs say to install Visual Studio Build Tools with "Desktop development with C++". Links: Repo: crewAIInc/crewAI Docs: docs.crewai.com Installation: docs.crewai.com Crews: docs.crewai.com Hierarchical process: docs.crewai.com Human feedback in Flows: docs.crewai.com Telemetry: docs.crewai.com Licence: github.com/crewAIInc/crewAI/blob/main/LICENSE Alternative: LangGraph, langchain-ai/langgraph Facts checked 2026-10-20 (CrewAI 1.15.28, 59,922 GitHub stars). An open-source (MIT) option to consider, not an endorsement; the hosted CrewAI AMP platform is a separate commercial product. Not affiliated with CrewAI (crewAI, Inc.) or LangChain. Narration: AI voice. #CrewAI #AIAgents #MultiAgent Chapters 0:00 Intro 0:11 The fix 0:28 How it works 0:43 Three real uses 1:04 The catch 1:27 Who it's for 1:38 Try it

One AI agent trying to do everything? 🤖 CrewAI lets you assign roles and tasks to cooperating agents. Experiment with research and multi-step workflows. 🧩 crewAIInc/crewAI #AIAgent #浇朋友 #蓝朋友 #互关 #fo

Before hiring an AI team, prove one agent cannot do the job. crewAI (~60k★): Coordinate role-based agents and tasks. crewAIInc/crewAI Which task deserves a specialist agent?

I Tried 100+ GitHub Repos for AI Engineering. These 8 Are the Best I went through 100+ GitHub repos for AI engineering and kept 8. Four to learn AI engineering in the right order, and four to build with: one for your data, your model, your agents, and your evals. If you're moving into AI engineering from data science or software, these are the free resources I'd actually use: LLMs, RAG, agents, local models and evaluation, all open source and linked below. ⏱️ Chapters 00:00 100+ repos, 8 worth keeping 00:56 1. Hands-On Large Language Models 01:46 2. LLMs from Scratch 02:55 3. Hugging Face Agents Course 03:49 4. AI Engineering (Chip Huyen) 05:01 5. Docling (data) 06:20 6. Ollama (model) 08:05 7. LangGraph (agents) 09:00 8. promptfoo (evals) 📚 Act 1: Learn Hands-On Large Language Models: HandsOnLLM/Hands-On-Large-Language-Models LLMs from Scratch: rasbt/LLMs-from-scratch Hugging Face Agents Course: huggingface/agents-course AI Engineering (Chip Huyen): chiphuyen/aie-book 🛠️ Act 2: Build Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Also mentioned MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Watch next youtu.be youtu.be youtu.be 🤖 AI consultancy services: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIEngineering #GitHub #LLM [ar] جربت أكثر من 100 مستودع على GitHub لهندسة الذكاء الاصطناعي. هذه الـ 8 هي الأفضل استعرضتُ أكثر من ١٠٠ مستودع على GitHub لهندسة الذكاء الاصطناعي، واحتفظتُ بثمانية منها. أربعة منها لتعلم هندسة الذكاء الاصطناعي بالترتيب الصحيح، وأربعة للبناء عليها: واحد لبياناتك، وواحد لنموذجك، وواحد للوكلاء، وواحد للتقييم. إذا كنتَ تنتقل إلى هندسة الذكاء الاصطناعي من علوم البيانات أو البرمجيات، فهذه هي الموارد المجانية التي أنصحك باستخدامها: نماذج التعلم الموجه (LLMs)، وRAG، والوكلاء، والنماذج المحلية، والتقييم، جميعها مفتوحة المصدر وروابطها موجودة أدناه. ⏱️ الفصول 00:00 أكثر من 100 مستودع، 8 منها تستحق الاحتفاظ بها 00:56 1. نماذج لغوية كبيرة عملية 01:46 2. بناء نماذج لغوية كبيرة من الصفر 02:55 3. دورة وكلاء Hugging Face 03:49 4. هندسة الذكاء الاصطناعي (تشيب هويين) 05:01 5. Docling (البيانات) 06:20 6. Ollama (النموذج) 08:05 7. LangGraph (الوكلاء) 09:00 8. promptfoo (التقييمات) 📚 الفصل الأول: التعلم نماذج لغوية كبيرة عملية: HandsOnLLM/Hands-On-Large-Language-Models نماذج لغوية كبيرة من الصفر: rasbt/LLMs-from-scratch Hugging Face دورة الوكلاء: huggingface/agents-course هندسة الذكاء الاصطناعي (تشيب هويين): chiphuyen/aie-book 🛠️ الفصل الثاني: البناء Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ مذكور أيضًا MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 شاهد التالي youtu.be youtu.be youtu.be 🤖 خدمات استشارية في مجال الذكاء الاصطناعي: anasriad.com 💼 لينكدإن: linkedin.com 💻 جيت هاب: github.com/anesriad #هندسة_الذكاء_الاصطناعي #جيت_هاب #ماجستير_قانون [bn] AI ইঞ্জিনিয়ারিংয়ের জন্য আমি ১০০+ গিটহাব রিপো ট্রাই করেছি। সেরা ৮টি এখানে। আমি এআই ইঞ্জিনিয়ারিং-এর জন্য ১০০টিরও বেশি গিটহাব রিপোজিটরি ঘেঁটে ৮টি রেখেছি। চারটি সঠিক ক্রমে এআই ইঞ্জিনিয়ারিং শেখার জন্য, এবং চারটি তৈরির জন্য: একটি আপনার ডেটার জন্য, একটি আপনার মডেলের জন্য, একটি এজেন্টের জন্য, এবং আপনার ইভ্যালুয়েশনের জন্য। আপনি যদি ডেটা সায়েন্স বা সফটওয়্যার থেকে এআই ইঞ্জিনিয়ারিং-এ আসেন, তাহলে এই বিনামূল্যের রিসোর্সগুলো আমি ব্যবহার করার পরামর্শ দেব: এলএলএম (LLM), র‍্যাগ (RAG), এজেন্ট, লোকাল মডেল এবং ইভ্যালুয়েশন, সবগুলোই ওপেন সোর্স এবং নিচে লিঙ্ক দেওয়া আছে। ⏱️ অধ্যায়সমূহ ০০:০০ ১০০+ রিপো, ৮টি রাখার মতো ০০:৫৬ ১. হ্যান্ডস-অন লার্জ ল্যাঙ্গুয়েজ মডেলস ০১:৪৬ ২. স্ক্র্যাচ থেকে এলএলএম ০২:৫৫ ৩. হাগিং ফেস এজেন্টস কোর্স ০৩:৪৯ ৪. এআই ইঞ্জিনিয়ারিং (চিপ হুয়েন) ০৫:০১ ৫. ডকলিং (ডেটা) ০৬:২০ ৬. ওলামা (মডেল) ০৮:০৫ ৭. ল্যাংগ্রাফ (এজেন্ট) ০৯:০০ ৮. প্রম্পটফু (ইভ্যাল) 📚 পর্ব ১: শিখুন হ্যান্ডস-অন লার্জ ল্যাঙ্গুয়েজ মডেলস: HandsOnLLM/Hands-On-Large-Language-Models স্ক্র্যাচ থেকে এলএলএম: rasbt/LLMs-from-scratch হাগিং ফেস এজেন্টস কোর্স: huggingface/agents-course এআই ইঞ্জিনিয়ারিং (চিপ হুয়েন): chiphuyen/aie-book 🛠️ পর্ব ২: তৈরি করুন ডকলিং: docling-project/docling ওলামা: ollama/ollama ল্যাংগ্রাফ: langchain-ai/langgraph প্রম্পটফু: promptfoo/promptfoo ➕ আরও উল্লেখিত মার্কইটডাউন: microsoft/markitdown আনস্ট্রাকচার্ড: Unstructured-IO/unstructured ভিএলএলএম: vllm-project/vllm ক্রুএআই: crewAIInc/crewAI স্মোলাজেন্টস: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 পরবর্তী ভিডিও দেখুন youtu.be youtu.be youtu.be 🤖 এআই পরামর্শ পরিষেবা: anasriad.com 💼 লিঙ্কডইন: linkedin.com 💻 গিটহাব: github.com/anesriad #AIEngineering #GitHub #LLM [de-DE] Ich habe über 100 GitHub-Repositories für KI-Engineering getestet. Diese 8 sind die besten Ich habe über 100 GitHub-Repos für KI-Engineering durchforstet und acht behalten. Vier davon, um KI-Engineering in der richtigen Reihenfolge zu lernen, und vier, um damit zu arbeiten: jeweils eines für Daten, Modelle, Agenten und Evaluierungen. Wenn Sie von Data Science oder Softwareentwicklung ins KI-Engineering wechseln, sind dies die kostenlosen Ressourcen, die ich tatsächlich nutzen würde: LLMs, RAG, Agenten, lokale Modelle und Evaluierung – alles Open Source und unten verlinkt. ⏱️ Kapitel 00:00 Über 100 Repositories, 8 davon sind empfehlenswert 00:56 1. Praktische Übungen mit großen Sprachmodellen 01:46 2. Sprachmodelle von Grund auf 02:55 3. Kurs „Hugging Face Agents“ 03:49 4. KI-Engineering (Chip Huyen) 05:01 5. Dokumentation (Daten) 06:20 6. Ollama (Modell) 08:05 7. LangGraph (Agenten) 09:00 8. promptfoo (Evaluierungen) 📚 Akt 1: Lernen Praktische Übungen mit großen Sprachmodellen: HandsOnLLM/Hands-On-Large-Language-Models Sprachmodelle von Grund auf: rasbt/LLMs-from-scratch Kurs „Hugging Face Agents“: huggingface/agents-course KI-Engineering (Chip Huyen): chiphuyen/aie-book 🛠️ Akt 2: Entwicklung Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Ebenfalls erwähnt: MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Nächstes Video ansehen: youtu.be youtu.be youtu.be 🤖 KI-Beratung: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #KI-Engineering #GitHub #LLM [es-US] Probé más de 100 repositorios de GitHub para ingeniería de IA. Estos 8 son los mejores Revisé más de 100 repositorios de GitHub sobre ingeniería de IA y me quedé con 8. Cuatro para aprender ingeniería de IA en el orden correcto y cuatro para desarrollar: uno para tus datos, otro para tu modelo, otro para tus agentes y otro para tus evaluaciones. Si vienes de la ciencia de datos o el desarrollo de software y te estás adentrando en la ingeniería de IA, estos son los recursos gratuitos que yo usaría: LLM, RAG, agentes, modelos locales y evaluación, todos de código abierto y enlazados a continuación. ⏱️ Capítulos 00:00 Más de 100 repositorios, 8 que vale la pena conservar 00:56 1. Modelos de lenguaje prácticos a gran escala 01:46 2. Modelos de lenguaje desde cero 02:55 3. Curso de agentes Hugging Face 03:49 4. Ingeniería de IA (Chip Huyen) 05:01 5. Documentación (datos) 06:20 6. Ollama (modelo) 08:05 7. LangGraph (agentes) 09:00 8. promptfoo (evaluaciones) 📚 Acto 1: Aprende Modelos de lenguaje prácticos a gran escala: HandsOnLLM/Hands-On-Large-Language-Models Modelos de lenguaje desde cero: rasbt/LLMs-from-scratch Curso de agentes Hugging Face: huggingface/agents-course Ingeniería de IA (Chip Huyen): chiphuyen/aie-book 🛠️ Acto 2: Construcción Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ También se menciona: MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Ver a continuación youtu.be youtu.be youtu.be 🤖 Servicios de consultoría de IA: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #IngenieríaIA #GitHub #LLM [fr-FR] J'ai testé plus de 100 dépôts GitHub pour l'ingénierie IA. Voici les 8 meilleurs J'ai exploré plus de 100 dépôts GitHub dédiés à l'ingénierie de l'IA et j'en ai retenu 8. Quatre pour apprendre l'ingénierie de l'IA dans le bon ordre, et quatre pour développer : un pour vos données, un pour votre modèle, un pour vos agents et un pour vos évaluations. Si vous vous orientez vers l'ingénierie de l'IA après avoir travaillé dans les sciences des données ou le développement logiciel, voici les ressources gratuites que j'utilise personnellement : LLM, RAG, agents, modèles locaux et évaluation, tous open source et disponibles via les liens ci-dessous. ⏱️ Chapitres 00:00 Plus de 100 dépôts, dont 8 à conserver 00:56 1. Modèles de langage complexes pratiques 01:46 2. Modèles de langage complexes à partir de zéro 02:55 3. Cours sur les agents Hugging Face 03:49 4. Ingénierie IA (Chip Huyen) 05:01 5. Docling (données) 06:20 6. Ollama (modèle) 08:05 7. LangGraph (agents) 09:00 8. Promptfoo (évaluations) 📚 Acte 1 : Apprendre Modèles de langage complexes pratiques : HandsOnLLM/Hands-On-Large-Language-Models Modèles de langage complexes à partir de zéro : rasbt/LLMs-from-scratch Cours sur les agents Hugging Face : huggingface/agents-course Ingénierie IA (Chip Huyen) : chiphuyen/aie-book 🛠️ Acte 2 : Création Docling : docling-project/docling Ollama : ollama/ollama LangGraph : langchain-ai/langgraph promptfoo : promptfoo/promptfoo ➕ Également mentionnés : MarkItDown : microsoft/markitdown Unstructured : Unstructured-IO/unstructured vLLM : vllm-project/vllm CrewAI : crewAIInc/crewAI smolagents : huggingface/smolagents Opik : comet-ml/opik DeepEval : confident-ai/deepeval DSPy : stanfordnlp/dspy 📺 À voir ensuite : youtu.be youtu.be youtu.be 🤖 Services de conseil en IA : anasriad.com 💼 LinkedIn : linkedin.com 💻 GitHub : github.com/anesriad #IngénierieAI #GitHub #LLM [hi] मैंने AI इंजीनियरिंग के लिए 100+ GitHub रिपोज़ आज़माए। ये 8 सबसे बेहतरीन हैं मैंने AI इंजीनियरिंग के लिए 100 से अधिक GitHub रिपॉजिटरी देखीं और उनमें से 8 को चुना। चार AI इंजीनियरिंग को सही क्रम में सीखने के लिए, और चार निर्माण के लिए: एक आपके डेटा के लिए, एक आपके मॉडल के लिए, एक आपके एजेंट्स के लिए और एक आपके मूल्यांकन के लिए। यदि आप डेटा साइंस या सॉफ्टवेयर से AI इंजीनियरिंग में आ रहे हैं, तो ये वे निःशुल्क संसाधन हैं जिनका मैं वास्तव में उपयोग करने की सलाह दूंगा: LLM, RAG, एजेंट्स, लोकल मॉडल और मूल्यांकन, ये सभी ओपन सोर्स हैं और नीचे लिंक दिए गए हैं। ⏱️ अध्याय 00:00 100+ रिपॉजिटरी, 8 रखने लायक 00:56 1. बड़े भाषा मॉडल पर व्यावहारिक अनुभव 01:46 2. एलएलएम की शुरुआत 02:55 3. हगिंग फेस एजेंट्स कोर्स 03:49 4. एआई इंजीनियरिंग (चिप हुएन) 05:01 5. डॉकलिंग (डेटा) 06:20 6. ओलामा (मॉडल) 08:05 7. लैंगग्राफ (एजेंट) 09:00 8. प्रॉम्प्टफू (मूल्यांकन) 📚 पहला भाग: सीखें बड़े भाषा मॉडल पर व्यावहारिक अनुभव: HandsOnLLM/Hands-On-Large-Language-Models एलएलएम की शुरुआत: rasbt/LLMs-from-scratch हगिंग फेस एजेंट्स कोर्स: huggingface/agents-course एआई इंजीनियरिंग (चिप हुएन): chiphuyen/aie-book 🛠️ चरण 2: निर्माण डॉकलिंग: docling-project/docling ओलामा: ollama/ollama लैंगग्राफ: langchain-ai/langgraph प्रॉम्प्टफू: promptfoo/promptfoo ➕ अन्य उल्लेख मार्कइटडाउन: microsoft/markitdown अनस्ट्रक्चर्ड: Unstructured-IO/unstructured vLLM: vllm-project/vllm क्रूएआई: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 अगला वीडियो देखें youtu.be youtu.be youtu.be 🤖 AI परामर्श सेवाएं: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIEngineering #GitHub #LLM [id] Saya Mencoba 100+ Repositori GitHub untuk Rekayasa AI. 8 Ini yang Terbaik Saya menelusuri lebih dari 100 repositori GitHub untuk rekayasa AI dan hanya menyimpan 8. Empat untuk mempelajari rekayasa AI dengan urutan yang benar, dan empat untuk membangunnya: satu untuk data Anda, model Anda, agen Anda, dan evaluasi Anda. Jika Anda beralih ke rekayasa AI dari ilmu data atau perangkat lunak, ini adalah sumber daya gratis yang sebenarnya akan saya gunakan: LLM, RAG, agen, model lokal dan evaluasi, semuanya sumber terbuka dan tautannya ada di bawah. ⏱️ Bab 00:00 100+ repositori, 8 yang layak disimpan 00:56 1. Praktik Model Bahasa Besar 01:46 2. LLM dari Awal 02:55 3. Kursus Agen Wajah Berpelukan 03:49 4. Rekayasa AI (Chip Huyen) 05:01 5. Docling (data) 06:20 6. Ollama (model) 08:05 7. LangGraph (agen) 09:00 8. promptfoo (evaluasi) 📚 Bab 1: Belajar Praktik Model Bahasa Besar: HandsOnLLM/Hands-On-Large-Language-Models LLM dari Awal: rasbt/LLMs-from-scratch Kursus Agen Wajah Berpelukan: huggingface/agents-course AI Engineering (Chip Huyen): chiphuyen/aie-book 🛠️ Babak 2: Membangun Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Juga disebutkan MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Tonton selanjutnya youtu.be youtu.be youtu.be 🤖 Layanan konsultasi AI: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIEngineering #GitHub #LLM [it] Ho provato oltre 100 repository GitHub per l'ingegneria dell'IA. Queste 8 sono le migliori Ho esaminato oltre 100 repository GitHub sull'ingegneria dell'IA e ne ho tenuti 8. Quattro per imparare l'ingegneria dell'IA nel modo corretto e quattro per sviluppare: uno per i dati, uno per il modello, uno per gli agenti e uno per le valutazioni. Se state passando all'ingegneria dell'IA dalla scienza dei dati o dallo sviluppo software, queste sono le risorse gratuite che vi consiglio di utilizzare: modelli lineari lineari (LLM), grafi aciclici direzionali (RAG), agenti, modelli locali e valutazione, tutti open source e i cui link trovate qui sotto. ⏱️ Capitoli 00:00 Oltre 100 repository, 8 da conservare 00:56 1. Modelli linguistici di grandi dimensioni pratici 01:46 2. Modelli linguistici di grandi dimensioni da zero 02:55 3. Corso sugli agenti "Hugging Face" 03:49 4. Ingegneria dell'IA (Chip Huyen) 05:01 5. Docling (dati) 06:20 6. Ollama (modello) 08:05 7. LangGraph (agenti) 09:00 8. promptfoo (valutazioni) 📚 Atto 1: Impara Modelli linguistici di grandi dimensioni pratici: HandsOnLLM/Hands-On-Large-Language-Models Modelli linguistici di grandi dimensioni da zero: rasbt/LLMs-from-scratch Corso sugli agenti "Hugging Face": Italiano: huggingface/agents-course Ingegneria dell'IA (Chip Huyen): chiphuyen/aie-book 🛠️ Atto 2: Creazione Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Menzionati anche MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: Italiano: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Guarda il prossimo video youtu.be youtu.be youtu.be 🤖 Servizi di consulenza AI: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIEngineering #GitHub #LLM [iw] בדקתי מעל 100 מאגרי GitHub להנדסת AI. אלו ה-8 הכי טובים עברתי על יותר מ-100 מאגרים ב-GitHub להנדסת בינה מלאכותית ושמרתי 8. ארבעה כדי ללמוד הנדסת בינה מלאכותית בסדר הנכון, וארבעה כדי לבנות איתם: אחד עבור הנתונים שלך, המודל שלך, הסוכנים שלך והערכות שלך. אם אתה עובר להנדסת בינה מלאכותית ממדעי נתונים או תוכנה, אלה המשאבים החינמיים שהייתי משתמש בהם בפועל: תואר ראשון במשפטים, תואר RAG, סוכנים, מודלים מקומיים והערכה, כולם בקוד פתוח ומקושרים למטה. ⏱️ פרקים 00:00 100+ מאגרים, 8 שכדאי לשמור 00:56 1. מודלים מעשיים לשפה גדולה 01:46 2. תואר ראשון במשפטים מאפס 02:55 3. קורס סוכני פנים מחבקים 03:49 4. הנדסת בינה מלאכותית (צ'יפ הויאן) 05:01 5. תיעוד (נתונים) 06:20 6. אולמה (מודל) 08:05 7. LangGraph (סוכנים) 09:00 8. promptfoo (הערכות) 📚 פרק 1: לימוד מודלים מעשיים לשפה גדולה: HandsOnLLM/Hands-On-Large-Language-Models תואר ראשון במשפטים מאפס: rasbt/LLMs-from-scratch קורס סוכני פנים מחבקים: huggingface/agents-course הנדסת בינה מלאכותית (צ'יפ הויאן): chiphuyen/aie-book 🛠️ מערכה 2: בנייה Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ הוזכר גם MarkItDown: microsoft/markitdown לא מובנה: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents אופיק: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 צפו בהמשך youtu.be youtu.be youtu.be 🤖 שירותי ייעוץ לבינה מלאכותית: anasriad.com 💼 לינקדאין: linkedin.com 💻 גיטהאב: github.com/anesriad #הנדסתבינה מלאכותית #GitHub #LLM [ja] AIエンジニア向けGitHubリポジトリ100選を試した結果、選りすぐりの8つを紹介します AIエンジニアリング関連のGitHubリポジトリを100以上チェックし、8つを選びました。そのうち4つはAIエンジニアリングを正しい順序で学ぶためのもので、残りの4つは実際に構築するためのものです。データ、モデル、エージェント、評価のためのリポジトリがそれぞれ1つずつです。 データサイエンスやソフトウェア開発からAIエンジニアリングに移行する場合、私が実際に活用するであろう無料リソースは以下の通りです。LLM、RAG、エージェント、ローカルモデル、評価など、すべてオープンソースで、以下にリンクを掲載しています。 ⏱️ チャプター 00:00 100以上のリポジトリ、厳選8つ 00:56 1. 大規模言語モデルの実践 01:46 2. ゼロから始める大規模言語モデル 02:55 3. ハグフェイスエージェントコース 03:49 4. AIエンジニアリング（チップ・フエン） 05:01 5. Docling（データ） 06:20 6. Ollama（モデル） 08:05 7. LangGraph（エージェント） 09:00 8. promptfoo（評価） 📚 第1幕：学習 大規模言語モデルの実践：HandsOnLLM/Hands-On-Large-Language-Models ゼロから始める大規模言語モデル：rasbt/LLMs-from-scratch ハグフェイスエージェントコース： huggingface/agents-course AIエンジニアリング（Chip Huyen）：chiphuyen/aie-book 🛠️ 第2幕：構築 Docling：docling-project/docling Ollama：ollama/ollama LangGraph：langchain-ai/langgraph promptfoo：promptfoo/promptfoo ➕ その他にも言及されているもの MarkItDown：microsoft/markitdown Unstructured：Unstructured-IO/unstructured vLLM：vllm-project/vllm CrewAI：crewAIInc/crewAI smolagents： huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 次の動画を見る youtu.be youtu.be youtu.be 🤖 AIコンサルティングサービス: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIエンジニアリング #GitHub #LLM [ko] AI 엔지니어링 관련해서 100개 이상의 GitHub 저장소를 사용해 봤습니다. 그중 최고는 이 8개입니다. 저는 AI 엔지니어링 관련 GitHub 저장소 100개 이상을 살펴보고 그중 8개만 남겼습니다. 4개는 AI 엔지니어링을 올바른 순서로 학습하는 데 유용하고, 나머지 4개는 데이터, 모델, 에이전트, 평가 도구 구축에 활용할 수 있습니다. 데이터 과학이나 소프트웨어 개발에서 AI 엔지니어링으로 전향하는 경우, 제가 실제로 활용할 만한 무료 리소스는 다음과 같습니다: LLMs, RAG, 에이전트, 로컬 모델 및 평가 도구 (모두 오픈 소스이며 아래 링크 참조). ⏱️ 목차 00:00 100개 이상의 저장소 중 8개는 꼭 소장할 가치가 있습니다. 00:56 1. 대규모 언어 모델 실습 01:46 2. 처음부터 LLM 만들기 02:55 3. Hugging Face 에이전트 강좌 03:49 4. AI 엔지니어링 (Chip Huyen) 05:01 5. Docling (데이터) 06:20 6. Ollama (모델) 08:05 7. LangGraph (에이전트) 09:00 8. promptfoo (평가) 📚 1막: 학습 대규모 언어 모델 실습: HandsOnLLM/Hands-On-Large-Language-Models 처음부터 LLM 만들기: rasbt/LLMs-from-scratch Hugging Face 에이전트 강좌: huggingface/agents-course AI 엔지니어링(칩 후옌): chiphuyen/aie-book 🛠️ 2막: 구축 Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ 언급된 다른 도구들 MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 다음 영상 보기 youtu.be youtu.be youtu.be 🤖 AI 컨설팅 서비스: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AI엔지니어링 #GitHub #LLM [ml] AI എഞ്ചിനീയറിംഗിനായി ഞാൻ 100-ലധികം GitHub റിപ്പോസിറ്ററികൾ പരീക്ഷിച്ചു. ഇവ 8 എണ്ണമാണ് ഏറ്റവും മികച... AI എഞ്ചിനീയറിങ്ങിനായി ഞാൻ 100+ GitHub റിപ്പോകൾ പരിശോധിച്ചു, അതിൽ 8 എണ്ണം സൂക്ഷിച്ചു. ശരിയായ ക്രമത്തിൽ AI എഞ്ചിനീയറിങ് പഠിക്കാൻ നാലെണ്ണവും, നിങ്ങളുടെ ഡാറ്റ, നിങ്ങളുടെ മോഡൽ, നിങ്ങളുടെ ഏജന്റുമാർ, നിങ്ങളുടെ വിലയിരുത്തലുകൾ എന്നിവയ്ക്കായി നിർമ്മിക്കാൻ നാലെണ്ണവും. ഡാറ്റാ സയൻസിൽ നിന്നോ സോഫ്റ്റ്‌വെയറിൽ നിന്നോ നിങ്ങൾ AI എഞ്ചിനീയറിങ്ങിലേക്ക് മാറുകയാണെങ്കിൽ, ഞാൻ യഥാർത്ഥത്തിൽ ഉപയോഗിക്കുന്ന സൗജന്യ ഉറവിടങ്ങൾ ഇവയാണ്: LLM-കൾ, RAG, ഏജന്റുമാർ, ലോക്കൽ മോഡലുകൾ, മൂല്യനിർണ്ണയം, എല്ലാം ഓപ്പൺ സോഴ്‌സും താഴെ ലിങ്ക് ചെയ്തിട്ടുള്ളതുമാണ്. ⏱️ അധ്യായങ്ങൾ 00:00 100+ റിപ്പോകൾ, സൂക്ഷിക്കേണ്ട 8 എണ്ണം 00:56 1. ഹാൻഡ്സ്-ഓൺ ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ 01:46 2. സ്ക്രാച്ചിൽ നിന്നുള്ള എൽഎൽഎമ്മുകൾ 02:55 3. ഹഗ്ഗിംഗ് ഫേസ് ഏജന്റ്സ് കോഴ്സ് 03:49 4. എഐ എഞ്ചിനീയറിംഗ് (ചിപ്പ് ഹ്യൂയെൻ) 05:01 5. ഡോക്ലിംഗ് (ഡാറ്റ) 06:20 6. ഒല്ലാമ (മോഡൽ) 08:05 7. ലാങ്ഗ്രാഫ് (ഏജന്റുകൾ) 09:00 8. പ്രോംപ്റ്റ്ഫൂ (evals) 📚 ആക്ട് 1: പഠിക്കുക ഹാൻഡ്സ്-ഓൺ ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ: HandsOnLLM/Hands-On-Large-Language-Models സ്ക്രാച്ചിൽ നിന്നുള്ള എൽഎൽഎമ്മുകൾ: rasbt/LLMs-from-scratch ഹഗ്ഗിംഗ് ഫേസ് ഏജന്റ്സ് കോഴ്സ്: huggingface/agents-course AI എഞ്ചിനീയറിംഗ് (Chip Huyen): chiphuyen/aie-book 🛠️ ആക്റ്റ് 2: ബിൽഡ് ഡോക്ലിംഗ്: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ ഇതും പരാമർശിച്ചിട്ടുണ്ട് MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 അടുത്തത് കാണുക youtu.be youtu.be youtu.be 🤖 AI കൺസൾട്ടൻസി സേവനങ്ങൾ: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AI എഞ്ചിനീയറിംഗ് #GitHub #LLM [nl-NL] Ik heb 100+ GitHub-repositories geprobeerd voor AI Engineering. Deze 8 zijn de beste Ik heb meer dan 100 GitHub-repositories voor AI-engineering doorgenomen en er 8 bewaard. Vier om AI-engineering in de juiste volgorde te leren, en vier om mee te bouwen: één voor je data, één voor je model, één voor je agents en één voor je evaluaties. Als je vanuit data science of software de overstap maakt naar AI-engineering, zijn dit de gratis bronnen die ik zelf zou gebruiken: LLMs, RAG, agents, lokale modellen en evaluatie, allemaal open source en hieronder gelinkt. ⏱️ Hoofdstukken 00:00 Meer dan 100 repositories, 8 de moeite waard om te bewaren 00:56 1. Praktische oefeningen met grote taalmodellen 01:46 2. LLM's vanaf nul 02:55 3. Cursus 'Hugging Face Agents' 03:49 4. AI-engineering (Chip Huyen) 05:01 5. Docling (data) 06:20 6. Ollama (model) 08:05 7. LangGraph (agents) 09:00 8. promptfoo (evaluaties) 📚 Deel 1: Leren Praktische oefeningen met grote taalmodellen: HandsOnLLM/Hands-On-Large-Language-Models LLM's vanaf nul: rasbt/LLMs-from-scratch Cursus 'Hugging Face Agents': huggingface/agents-course AI Engineering (Chip Huyen): chiphuyen/aie-book 🛠️ Act 2: Bouwen Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Ook genoemd MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Bekijk volgende video's youtu.be youtu.be youtu.be 🤖 AI-consultancy: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIEngineering #GitHub #LLM [pa] ਮੈਂ AI ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ 100 ਤੋਂ ਵੱਧ GitHub ਰਿਪੋਜ਼ਿਟਰੀਆਂ ਅਜ਼ਮਾਈਆਂ। ਇਹ 8 ਸਭ ਤੋਂ ਵਧੀਆ ਹਨ ਮੈਂ AI ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ 100+ GitHub ਰਿਪੋਜ਼ ਵਿੱਚੋਂ ਲੰਘਿਆ ਅਤੇ 8 ਰੱਖੇ। ਚਾਰ ਸਹੀ ਕ੍ਰਮ ਵਿੱਚ AI ਇੰਜੀਨੀਅਰਿੰਗ ਸਿੱਖਣ ਲਈ, ਅਤੇ ਚਾਰ ਇਸ ਨਾਲ ਬਣਾਉਣ ਲਈ: ਇੱਕ ਤੁਹਾਡੇ ਡੇਟਾ, ਤੁਹਾਡੇ ਮਾਡਲ, ਤੁਹਾਡੇ ਏਜੰਟਾਂ ਅਤੇ ਤੁਹਾਡੇ ਮੁਲਾਂਕਣ ਲਈ। ਜੇਕਰ ਤੁਸੀਂ ਡੇਟਾ ਸਾਇੰਸ ਜਾਂ ਸੌਫਟਵੇਅਰ ਤੋਂ AI ਇੰਜੀਨੀਅਰਿੰਗ ਵਿੱਚ ਜਾ ਰਹੇ ਹੋ, ਤਾਂ ਇਹ ਉਹ ਮੁਫਤ ਸਰੋਤ ਹਨ ਜੋ ਮੈਂ ਅਸਲ ਵਿੱਚ ਵਰਤਾਂਗਾ: LLM, RAG, ਏਜੰਟ, ਸਥਾਨਕ ਮਾਡਲ ਅਤੇ ਮੁਲਾਂਕਣ, ਸਾਰੇ ਓਪਨ ਸੋਰਸ ਅਤੇ ਹੇਠਾਂ ਲਿੰਕ ਕੀਤੇ ਗਏ ਹਨ। ⏱️ ਅਧਿਆਏ 00:00 100+ ਰਿਪੋ, 8 ਰੱਖਣ ਦੇ ਯੋਗ 00:56 1. ਹੈਂਡਸ-ਆਨ ਲਾਰਜ ਲੈਂਗਵੇਜ ਮਾਡਲ 01:46 2. ਸਕ੍ਰੈਚ ਤੋਂ ਐਲਐਲਐਮ 02:55 3. ਹੱਗਿੰਗ ਫੇਸ ਏਜੰਟ ਕੋਰਸ 03:49 4. ਏਆਈ ਇੰਜੀਨੀਅਰਿੰਗ (ਚਿੱਪ ਹਿਊਯੇਨ) 05:01 5. ਡੌਕਲਿੰਗ (ਡੇਟਾ) 06:20 6. ਓਲਾਮਾ (ਮਾਡਲ) 08:05 7. ਲੈਂਗਗ੍ਰਾਫ (ਏਜੰਟ) 09:00 8. ਪ੍ਰੋਂਪਟਫੂ (ਈਵਾਲਜ਼) 📚 ਐਕਟ 1: ਸਿੱਖੋ ਹੱਗਿੰਗ ਫੇਸ ਏਜੰਟ ਕੋਰਸ: HandsOnLLM/Hands-On-Large-Language-Models ਸਕ੍ਰੈਚ ਤੋਂ ਐਲਐਲਐਮ: rasbt/LLMs-from-scratch ਹੱਗਿੰਗ ਫੇਸ ਏਜੰਟ ਕੋਰਸ: huggingface/agents-course AI ਇੰਜੀਨੀਅਰਿੰਗ (ਚਿੱਪ ਹੁਯੇਨ): chiphuyen/aie-book 🛠️ ਐਕਟ 2: ਬਿਲਡ ਡੌਕਲਿੰਗ: docling-project/docling ਓਲਾਮਾ: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ ਇਹ ਵੀ ਜ਼ਿਕਰ ਕੀਤਾ ਗਿਆ ਹੈ ਮਾਰਕਇਟਡਾਊਨ: microsoft/markitdown ਅਨਸਟ੍ਰਕਚਰਡ: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents ਓਪਿਕ: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 ਅੱਗੇ ਦੇਖੋ youtu.be youtu.be youtu.be 🤖 AI ਸਲਾਹਕਾਰ ਸੇਵਾਵਾਂ: anasriad.com 💼 ਲਿੰਕਡਇਨ: linkedin.com 💻 GitHub: github.com/anesriad #AIEngineering #GitHub #LLM [pl] Przetestowałem ponad 100 repozytoriów na GitHubie do nauki inżynierii AI. Te 8 jest najlepszych Przejrzałem ponad 100 repozytoriów GitHub dotyczących inżynierii AI i zachowałem 8. Cztery, aby nauczyć się inżynierii AI we właściwej kolejności i cztery do budowania: jedno dla danych, modelu, agentów i ewaluacji. Jeśli przechodzisz do inżynierii AI z zakresu nauki o danych lub oprogramowania, oto darmowe zasoby, z których faktycznie skorzystałbym: LLM, RAG, agenci, modele lokalne i ewaluacja – wszystkie open source i linki poniżej. ⏱️ Rozdziały 00:00 Ponad 100 repozytoriów, 8 wartych zachowania 00:56 1. Praktyczne modele językowe 01:46 2. Studia magisterskie od podstaw 02:55 3. Kurs agentów Hugging Face 03:49 4. Inżynieria AI (Chip Huyen) 05:01 5. Dokumentowanie (dane) 06:20 6. Ollama (model) 08:05 7. LangGraph (agenci) 09:00 8. promptfoo (ewaluacje) 📚 Akt 1: Nauka Praktyczne modele językowe: HandsOnLLM/Hands-On-Large-Language-Models Studia magisterskie od podstaw: rasbt/LLMs-from-scratch Kurs agentów Hugging Face: huggingface/agents-course Inżynieria AI (Chip Huyen): chiphuyen/aie-book 🛠️ Akt 2: Kompilacja Dokumentacja: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Wspomniano również MarkItDown: microsoft/markitdown Niestrukturalny: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Oglądaj Dalej youtu.be youtu.be youtu.be 🤖 Usługi konsultingowe w zakresie sztucznej inteligencji: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIengineering #GitHub #LLM [pt-BR] Testei mais de 100 repositórios do GitHub para Engenharia de IA. Estes 8 são os melhores Analisei mais de 100 repositórios do GitHub sobre engenharia de IA e selecionei 8. Quatro para aprender engenharia de IA na ordem correta e quatro para desenvolver: um para seus dados, um para seu modelo, um para seus agentes e um para suas avaliações. Se você está migrando para a engenharia de IA vindo da ciência de dados ou do software, estes são os recursos gratuitos que eu realmente usaria: LLMs, RAG, agentes, modelos locais e avaliação, todos de código aberto e com links abaixo. ⏱️ Capítulos 00:00 Mais de 100 repositórios, 8 que valem a pena manter 00:56 1. Modelos de Linguagem Grandes na Prática 01:46 2. Modelos de Linguagem Grandes do Zero 02:55 3. Curso de Agentes Hugging Face 03:49 4. Engenharia de IA (Chip Huyen) 05:01 5. Docling (dados) 06:20 6. Ollama (modelo) 08:05 7. LangGraph (agentes) 09:00 8. promptfoo (avaliações) 📚 Ato 1: Aprenda Modelos de Linguagem Grandes na Prática: HandsOnLLM/Hands-On-Large-Language-Models Modelos de Linguagem Grandes do Zero: rasbt/LLMs-from-scratch Curso de Agentes Hugging Face: Curso de Agentes: huggingface/agents-course Engenharia de IA (Chip Huyen): chiphuyen/aie-book 🛠️ Ato 2: Construir Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Também mencionado MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Assista a seguir youtu.be youtu.be youtu.be 🤖 Serviços de consultoria em IA: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #EngenhariaDeIA #GitHub #LLM [ru] Я протестировал более 100 GitHub-репозиториев по AI-инженерии. Эти 8 — лучшие Я просмотрел более 100 репозиториев GitHub по разработке ИИ и сохранил 8. Четыре — для изучения ИИ в правильной последовательности, и четыре — для построения модели: один для данных, один для агентов и один для оценки. Если вы переходите в разработку ИИ из области анализа данных или разработки программного обеспечения, вот бесплатные ресурсы, которые я бы действительно использовал: LLMs, RAG, агенты, локальные модели и оценка — все с открытым исходным кодом и ссылки на них ниже. ⏱️ Разделы 00:00 Более 100 репозиториев, 8 из которых стоит сохранить 00:56 1. Практическое применение больших языковых моделей 01:46 2. Создание больших языковых моделей с нуля 02:55 3. Курс по агентам «Обнимающее лицо» 03:49 4. Разработка ИИ (Чип Хуен) 05:01 5. Docling (данные) 06:20 6. Ollama (модель) 08:05 7. LangGraph (агенты) 09:00 8. promptfoo (оценки) 📚 Часть 1: Обучение Практическое применение больших языковых моделей: HandsOnLLM/Hands-On-Large-Language-Models Создание больших языковых моделей с нуля: rasbt/LLMs-from-scratch Обнимающее лицо Курс по агентам: huggingface/agents-course Инженерное дело в области ИИ (Чип Хуен): chiphuyen/aie-book 🛠️ Акт 2: Создание Docling: docling-project/docling Ollama: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Также упоминалось MarkItDown: microsoft/markitdown Unstructured: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Opik: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Смотрите далее youtu.be youtu.be youtu.be 🤖 Услуги консалтинга в области ИИ: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #AIEngineering #GitHub #LLM [ta] AI இன்ஜினியரிங் க்காக 100+ GitHub களஞ்சியங்களை முயற்சித்தேன். இதோ சிறந்த 8 களஞ்சியங்கள் நான் AI பொறியியலுக்கான 100-க்கும் மேற்பட்ட GitHub ரெப்போக்களைப் பார்த்து, அவற்றில் 8-ஐத் தேர்ந்தெடுத்தேன். AI பொறியியலைச் சரியான வரிசையில் கற்றுக்கொள்வதற்கு நான்கு, மற்றும் கட்டமைப்பதற்கு நான்கு: ஒன்று உங்கள் தரவுகளுக்கும், மற்றொன்று உங்கள் மாடலுக்கும், மற்றொன்று உங்கள் ஏஜென்ட்களுக்கும், மற்றும் உங்கள் மதிப்பீடுகளுக்கும். நீங்கள் தரவு அறிவியல் அல்லது மென்பொருளிலிருந்து AI பொறியியலுக்கு மாறுகிறீர்கள் என்றால், நான் உண்மையில் பயன்படுத்தும் இலவச ஆதாரங்கள் இவைதான்: LLM-கள், RAG, ஏஜென்ட்கள், உள்ளூர் மாடல்கள் மற்றும் மதிப்பீடு, இவை அனைத்தும் திறந்த மூல மென்பொருட்கள் மற்றும் கீழே இணைக்கப்பட்டுள்ளன. ⏱️ அத்தியாயங்கள் 00:00 100+ ரெப்போக்கள், 8 வைத்திருக்கத் தகுந்தவை 00:56 1. பெரிய மொழி மாதிரிகளில் செய்முறைப் பயிற்சி 01:46 2. புதிதாக LLM-கள் 02:55 3. ஹக்கிங் ஃபேஸ் ஏஜென்ட்ஸ் பாடநெறி 03:49 4. AI பொறியியல் (சிப் ஹுயென்) 05:01 5. டாக்லிங் (தரவு) 06:20 6. ஒல்லாமா (மாடல்) 08:05 7. லாங்க்கிராஃப் (ஏஜென்ட்கள்) 09:00 8. ப்ராம்ட்ஃபூ (மதிப்பீடுகள்) 📚 பகுதி 1: கற்றல் பெரிய மொழி மாதிரிகளில் செய்முறைப் பயிற்சி: HandsOnLLM/Hands-On-Large-Language-Models புதிதாக LLM-கள்: rasbt/LLMs-from-scratch ஹக்கிங் ஃபேஸ் ஏஜென்ட்ஸ் பாடநெறி: huggingface/agents-course AI பொறியியல் (சிப் ஹுயென்): chiphuyen/aie-book 🛠️ பகுதி 2: உருவாக்குதல் டாக்லிங்: docling-project/docling ஒல்லாமா: ollama/ollama லாங்கிராஃப்: langchain-ai/langgraph ப்ராம்ட்ஃபூ: promptfoo/promptfoo ➕ மேலும் குறிப்பிடப்பட்டவை மார்க்இட்டவுன்: microsoft/markitdown அன்ஸ்ட்ரக்சர்டு: Unstructured-IO/unstructured விஎல்எல்எம்: vllm-project/vllm க்ரூஏஐ: crewAIInc/crewAI ஸ்மோலாஜென்ட்ஸ்: huggingface/smolagents ஓபிக்: comet-ml/opik டீப்ஈவால்: confident-ai/deepeval டிஎஸ்பிஒய்: stanfordnlp/dspy 📺 அடுத்துப் பார்க்கவும் youtu.be youtu.be youtu.be 🤖 செயற்கை நுண்ணறிவு ஆலோசனை சேவைகள்: anasriad.com 💼 லிங்க்ட்இன்: linkedin.com 💻 கிட்ஹப்: github.com/anesriad #செயற்கை நுண்ணறிவு பொறியியல் #கிட்ஹப் #எல்எல்எம் [te] AI ఇంజనీరింగ్ కోసం 100+ GitHub రిపోలను ప్రయత్నించాను. అందులో ఇవే ఉత్తమమైన 8 నేను AI ఇంజనీరింగ్ కోసం 100కు పైగా గిట్‌హబ్ రిపోలను పరిశీలించి, వాటిలో 8 ఉంచుకున్నాను. వాటిలో నాలుగు సరైన క్రమంలో AI ఇంజనీరింగ్ నేర్చుకోవడానికి, మిగిలిన నాలుగు నిర్మించడానికి: ఒకటి మీ డేటా కోసం, ఒకటి మీ మోడల్ కోసం, ఒకటి మీ ఏజెంట్ల కోసం, మరియు ఒకటి మీ ఎవాల్యుయేషన్ల కోసం. మీరు డేటా సైన్స్ లేదా సాఫ్ట్‌వేర్ నుండి AI ఇంజనీరింగ్‌లోకి వస్తున్నట్లయితే, నేను నిజంగా ఉపయోగించే ఉచిత వనరులు ఇవే: LLMలు, RAG, ఏజెంట్లు, లోకల్ మోడల్స్ మరియు ఎవాల్యుయేషన్, ఇవన్నీ ఓపెన్ సోర్స్ మరియు కింద లింక్ చేయబడ్డాయి. ⏱️ అధ్యాయాలు 00:00 100+ రిపోలు, ఉంచుకోవాల్సినవి 8 00:56 1. పెద్ద భాషా నమూనాలపై ఆచరణాత్మక శిక్షణ 01:46 2. మొదటి నుండి LLMలు 02:55 3. హగ్గింగ్ ఫేస్ ఏజెంట్స్ కోర్సు 03:49 4. AI ఇంజనీరింగ్ (చిప్ హుయెన్) 05:01 5. డాక్లింగ్ (డేటా) 06:20 6. ఒల్లామా (మోడల్) 08:05 7. లాంగ్‌గ్రాఫ్ (ఏజెంట్లు) 09:00 8. ప్రాంప్ట్‌ఫూ (మూల్యాంకనాలు) 📚 మొదటి భాగం: నేర్చుకోండి పెద్ద భాషా నమూనాలపై ఆచరణాత్మక శిక్షణ: HandsOnLLM/Hands-On-Large-Language-Models మొదటి నుండి LLMలు: rasbt/LLMs-from-scratch హగ్గింగ్ ఫేస్ ఏజెంట్స్ కోర్సు: huggingface/agents-course AI ఇంజనీరింగ్ (చిప్ హుయెన్): chiphuyen/aie-book 🛠️ రెండవ అంకం: నిర్మాణం డాక్లింగ్: docling-project/docling ఒల్లామా: ollama/ollama లాంగ్‌గ్రాఫ్: langchain-ai/langgraph ప్రాంప్ట్‌ఫూ: promptfoo/promptfoo ➕ ఇక్కడ కూడా ప్రస్తావించబడింది మార్క్‌ఇట్‌డౌన్: microsoft/markitdown అన్‌స్ట్రక్చర్డ్: Unstructured-IO/unstructured vLLM: vllm-project/vllm క్రూAI: crewAIInc/crewAI స్మోలాజెంట్స్: huggingface/smolagents ఓపిక్: comet-ml/opik డీప్ఈవాల్: confident-ai/deepeval డీఎస్పీవై: stanfordnlp/dspy 📺 తదుపరి చూడండి youtu.be youtu.be youtu.be 🤖 ఏఐ కన్సల్టెన్సీ సేవలు: anasriad.com 💼 లింక్డ్‌ఇన్: linkedin.com 💻 గిట్‌హబ్: github.com/anesriad #ఏఐఇంజనీరింగ్ #గిట్‌హబ్ #ఎల్‌ఎల్‌ఎం [uk] Я перевірив понад 100 GitHub-репозиторіїв для AI-інженерії. Ці 8 — найкращі Я переглянув понад 100 репозиторіїв GitHub з питань штучного інтелекту та залишив 8. Чотири для вивчення ШІ-інженерії в правильному порядку та чотири для побудови: по одному для ваших даних, вашої моделі, ваших агентів та ваших оцінок. Якщо ви переходите до ШІ-інженерії з науки про дані чи програмного забезпечення, ось безкоштовні ресурси, які я б насправді використовував: LLM, RAG, агенти, локальні моделі та оцінка, всі з відкритим вихідним кодом та посилання на які нижче. ⏱️ Розділи 00:00 100+ репозиторіїв, 8 варті того, щоб зберегти 00:56 1. Практичні моделі великих мов 01:46 2. LLM з нуля 02:55 3. Курс про агенти, що обіймають обличчя 03:49 4. Інженерія штучного інтелекту (Чіп Х'юєн) 05:01 5. Доклінг (дані) 06:20 6. Ollama (модель) 08:05 7. LangGraph (агенти) 09:00 8. promptfoo (оцінки) 📚 Акт 1: Вивчення Практичні моделі великих мов: HandsOnLLM/Hands-On-Large-Language-Models LLM з нуля: rasbt/LLMs-from-scratch Курс про агенти, що обіймають обличчя: huggingface/agents-course Інженерія штучного інтелекту (Чіп Х'юєн): chiphuyen/aie-book 🛠️ Акт 2: Збірка Доклінг: docling-project/docling Оллама: ollama/ollama LangGraph: langchain-ai/langgraph promptfoo: promptfoo/promptfoo ➕ Також згадано MarkItDown: microsoft/markitdown Неструктурований: Unstructured-IO/unstructured vLLM: vllm-project/vllm CrewAI: crewAIInc/crewAI smolagents: huggingface/smolagents Опік: comet-ml/opik DeepEval: confident-ai/deepeval DSPy: stanfordnlp/dspy 📺 Дивитися далі youtu.be youtu.be youtu.be 🤖 Консалтингові послуги зі штучного інтелекту: anasriad.com 💼 LinkedIn: linkedin.com 💻 GitHub: github.com/anesriad #ІнженеріяШІ #GitHub #LLM

Escape SaaS Fees with Local AI (Self-Host n8n, Dify, Langflow & Ollama) Self-host n8n, Dify, Langflow and Ollama on one $10–15/month VPS: an open-source alternative to per-seat SaaS fees for AI automation. This local AI deep dive explains Docker, RAG, AI agents with CrewAI, and running models with no API bill. Repositories and commands are below. Tell us in the comments which subscription you would cancel first. CHAPTERS 0:00 The barrier-to-entry myth 2:06 The SaaS trap: $30/seat adds up fast 4:19 Is self-hosting hard? Docker explained 6:14 Visual workflow builders: n8n, Langflow, Flowise 10:13 Dify & RAG (vector embeddings made simple) 13:30 Autonomous AI agents & feedback loops 17:15 Install Dify in 3 commands 20:00 Ollama: zero API cost 21:31 Recap & the future REPOSITORIES IN THIS VIDEO n8n: n8n-io/n8n Langflow: langflow-ai/langflow Flowise: FlowiseAI/Flowise Dify: langgenius/dify CrewAI: crewAIInc/crewAI Langfuse: langfuse/langfuse Ollama: ollama/ollama MCP servers: modelcontextprotocol/servers Docker Compose: docker/compose COMMANDS SHOWN git clone langgenius/dify cd dify/docker cp .env.example .env docker compose up -d WHAT THIS COVERS A ChatGPT Team seat, Zapier and a CRM can cost a solo founder hundreds of dollars (around ₹15,000) a month before a single paying client. We walk through the alternative: rent a bare-bones VPS and run open-source AI tools on it, including how to choose between Langflow and Dify, how supervisor and worker agents check each other, and why you should bind internal ports to 127.0.0.1. WHO THIS IS FOR Solo founders, small agencies and teams that handle sensitive data, such as law firms, accountants and clinics. You don't need deep Linux knowledge, but you will use a terminal and Docker. Stock footage: Pexels and Pixabay (free licences). Hosts are AI-generated presenters. If this helped, subscribe to Daily Useful Steps. Small steps. Everyday wins. #AIAutomation #LocalAI #SelfHosted