标签：#ia

A competitor intelligence agent enables real-time pricing visibility, automated positioning tracking, and structured competitor briefs for brands without manual research. At the center of these workflows are a researcher agent responsible for gathering data and an analysis agent responsible for generating a summary and a downstream report. However, one of the things that makes the researcher agent's output trustworthy is its retrieval layer, since a poor retrieval-layer output can make the analysis agent's recommendation questionable. If the researcher agent searches the webpage and retrieves a challenge page, an empty response, or blocked content, every downstream conclusion becomes less trustworthy. With a 99.93% success rate on protected websites, ZenRows provides the reliable retrieval layer that makes these workflows practical in production. This tutorial shows why a CrewAI researcher agent can fail on protected competitor pages. It starts with a custom ZenRows-based tool setup, then later shows the MCP server as an alternative approach. Prerequisites This tutorial works best with Python 3.10 or newer. If you are on an older Python version, create a dedicated virtual environment with a current Python installation to avoid dependency conflicts. Python 3.10 to 3.13. CrewAI requires this range. ZenRows API key. Create an account at zenrows.com and copy your key from the dashboard. This key authenticates every scrape the researcher agent runs for data extraction. Anthropic API key. The crew uses Claude to drive both agents. Generate a key in the Anthropic Console. Install dependencies and the required packages using pip install "crewai[anthropic]" crewai-tools zenrows python-dotenv . Create a .env file and save your API keys there. Why the built-in ScrapeWebsiteTool fails on competitor pages The problem, as established earlier, starts before the analysis. A CrewAI workflow depends primarily on the information collected, because a competitor intelligence agent relie

From data preparation and tokenizer selection to pretraining, LoRA, RLHF, evaluation, and production monitoring, this guide covers the major stages involved in training an AI model. Training an artificial intelligence model is not simply a matter of loading a dataset onto a GPU and running a few commands. A successful model requires a measurable objective, legally usable and carefully cleaned data, an architecture suited to the problem, controlled optimization, independent evaluation, and continuous monitoring after deployment. In large language model development, a mistake in any one of these stages can waste millions of training examples and a significant amount of compute. This guide explains the model development process primarily through the training of large language models. However, fundamental concepts such as dataset splitting, loss functions, overfitting, and evaluation also apply to computer vision, speech, and predictive models. The goal is not to provide a single fixed recipe. Instead, it is to explain which training approach is appropriate for which problem and to clarify the cost difference between training a model from scratch and adapting an existing model. In Brief: How Is an AI Model Trained? First, the target task and success criteria are defined. Data is collected, reviewed for licensing and privacy, cleaned, and divided into training, validation, and test sets. The model generates predictions from the input data. The difference between the prediction and the correct target is measured using a loss function. Backpropagation calculates how each parameter contributed to the error, and an optimization algorithm updates the parameters. This process is repeated under controlled conditions until the model achieves acceptable results in independent tests and safety evaluations. What Does Training a Model Actually Mean? A neural network initially contains a large number of numerical parameters. During training, the model generates a prediction for a giv

Elon Musk's xAI files first lawsuit against Grok user accused of making child sex images.

Hyundai aims to deploy 25,000 Atlas robots starting with US factories in 2028.

The social-engineering technique has primarily been a tool of financially motivated criminals.

Cyclosporiasis isn’t the only thing spreading across the US. So is anxiety about getting hit with it.

The company endorsed landmark AI transparency laws in California and New York last year, but its head of US state and local policy says they may already be outdated.

X will use Grok AI to better detect stolen content, redirect payouts to original creators, and crack down on engagement bait.

You're paying $10 to $20 a month for Copilot. You don't have to. A 2024-era laptop can run a coding model good enough for autocomplete, refactors, and "explain this function" entirely offline. No API key, no telemetry, no per-token bill. Here's the exact 2026 setup I run on a 16GB machine. Why local in 2026 Two years ago, local coding models were a toy. The autocomplete was slow and the suggestions were noise. That changed. qwen2.5-coder and deepseek-coder-v2 are genuinely useful now, and the tooling caught up: Ollama serves them, Continue.dev wires them into your editor, and the whole thing runs on hardware you already own. The pitch is simple: Free. No subscription, no usage caps. Private. Your proprietary code never leaves the machine. This matters if you work on smart contracts or anything under NDA. Offline. Works on a plane, in a basement, behind a corporate firewall. The tradeoff is quality and latency. We'll be honest about both. Pick a model (and match it to your RAM) This is the decision that makes or breaks the experience. Pick a model your machine can actually hold in memory, or it spills to disk and crawls. # Fast, fits anywhere (8GB+) ollama pull qwen2.5-coder:1.5b # ~1.0GB ollama pull qwen2.5-coder:3b # ~1.9GB # The sweet spot for most laptops (16GB) ollama pull qwen2.5-coder:7b # ~4.7GB # Quality tier, needs headroom (32GB+ comfortable) ollama pull deepseek-coder-v2 # ~8.9GB (16b MoE) ollama pull qwen2.5-coder:14b # ~9.0GB ollama pull qwen2.5-coder:32b # ~20GB Rough rule: the model file size is the floor, then add a few GB for context and the OS. A 4.7GB model on a 16GB machine is comfortable. A 20GB model on the same machine is not. Model Size RAM I'd want Use it for qwen2.5-coder:1.5b 1.0GB 8GB Autocomplete, fast iteration qwen2.5-coder:7b 4.7GB 16GB Daily driver: chat, refactors, explain deepseek-coder-v2 8.9GB 32GB Harder reasoning, multi-file context qwen2.5-coder:32b 20GB 64GB Near-cloud quality, if you have the RAM deepseek-coder-v2 is a 16b m

Exposing your data over MCP is the easy part. Designing a tool an agent uses well is the hard part. An agent can only use a tool it can read, so the work is shaping the tool for how the model calls it, not just for the human looking at the result. These are the techniques behind @bonnard/mcp-charts and the visualize tool. Discovery-first, so the agent stops guessing An agent that guesses your schema writes wrong queries. So the first tool the agent meets is a discovery tool. It calls visualize_read_me to load the chart options, the tool schema, and worked examples before it ever calls visualize , and an explore_schema tool to learn your tables and columns before it writes SQL. The agent reads, then acts. A small set of purpose-built tools The temptation is one tool per metric, or a single tool that takes arbitrary SQL and hopes. Both fail: too many tools blow the agent's attention budget; one firehose tool gives it no guardrails. Bonnard ships a small set, discover, query, visualize, each with a narrow, obvious job. The agent picks the right one because there are few of them and each does one thing. // a small, purpose-built set, not one tool per metric server . registerTool ( " explore_schema " , { /* list tables + columns */ }, listSchema ); addCharts ( server , { runSql }); // registers visualize_read_me + visualize Compact, honest responses A tool that returns 10,000 raw rows poisons the context window and the agent's next decision. Bonnard's responses are sized for a model to read: Row caps with a completeness flag. Results are capped and tagged partial or complete , so the agent knows whether it is looking at everything. Partial-result warnings. When results are capped, the response says so and tells the agent not to sum or average the visible rows, use a measure instead. Summaries over dumps. The chart comes back with a compact text summary the model can reason over, not just an image it cannot read. Errors that guide the next action A bare "error: invalid co

Most teams connecting AI agents to their data warehouse start with text-to-SQL. The agent generates SQL from natural language, runs it against the warehouse, and returns results. It works until it doesn't: hallucinated JOINs, inconsistent aggregations, no access control, no audit trail. There's a better approach. Define your business metrics in a semantic layer, expose them via MCP (Model Context Protocol), and let any AI agent query governed definitions instead of raw tables. Then add one tool so the agent can chart the result in Claude or ChatGPT. This tutorial shows how to set it up in under 30 minutes. Why does text-to-SQL break in production? The agent sees column names but not business logic. It doesn't know that your company excludes refunds from revenue. It doesn't know that status = 'completed' means something different in orders than in subscriptions . It doesn't know that marketing and finance defined "active user" differently three years ago and never reconciled. So the agent writes plausible SQL and returns plausible numbers. Ask the same question twice with different phrasing and you get different answers. Ask two different agents and you get two different numbers. Neither matches the number your finance team reports. Beyond consistency, there's no row-level security. No multi-tenancy. No audit trail showing which agent queried what, when, and for whom. In production, with real customers, that's a non-starter. Text-to-SQL gives you speed. It doesn't give you trust. What is the semantic layer approach? Instead of letting agents write arbitrary SQL, define your metrics once in YAML: cubes, measures, dimensions, access rules. Then expose those definitions via MCP so agents query governed metrics, not raw tables. The difference: every agent gets the same answer because the metric definition is fixed. total_revenue isn't a column the agent interprets. It's a pre-defined calculation with agreed-upon filters and aggregations. When your finance team updates th

The regulator is assessing whether the platform is doing enough to protect children from harmful content.

Published to Dev.to — Bitcoin Development Series, Part 1 of 4_ Bitcoin is heading toward an August 2026 deadline for BIP-110, a proposed temporary softfork that would restrict Ordinals-style arbitrary data from being embedded in transactions for one year. As of today, miner signaling sits at effectively zero. The proposal is almost certainly going to fail but the mechanics of why and how are worth understanding if you work anywhere near the Bitcoin protocol. This post walks through how soft fork activation works, what BIP-110 specifically proposes, and how to inspect miner signaling yourself with code. What Is a Soft Fork? A soft fork is a backward-compatible change to Bitcoin's consensus rules. Nodes running old software still accept blocks from nodes running the new rules — but not vice versa. This is what makes soft forks safer than hard forks in a permissionless network: you do not force everyone to upgrade on day one. Hard forks, by contrast, change rules in a way that causes old nodes to reject new blocks entirely. They require near-universal coordination, which is why Bitcoin has avoided them. How Soft Fork Activation Works: BIP 9 The dominant activation mechanism used since 2016 is defined in BIP 9 . The process works like this: A proposal is assigned a version bit (bit 0–28) in the block header's nVersion field. Miners signal readiness by setting that bit in blocks they produce. Activation requires 95% of blocks in a 2,016-block retarget window to signal support. There is a starttime and a timeout . If the threshold is not met before timeout , the proposal fails and is discarded. # Simplified BIP 9 state machine logic THRESHOLD = 0.95 # 95% of blocks in a retarget window WINDOW = 2016 # one retarget period def check_activation ( signaling_blocks : int , total_blocks : int ) -> str : ratio = signaling_blocks / total_blocks if ratio >= THRESHOLD : return " LOCKED_IN " # activates after one more window return " STARTED " # still counting print ( check_activati

Dictionary ordering, key hashing, view objects, and the iteration traps that catch experienced developers. Dictionaries are the most used Python data structure in production code and one of the most tested in technical interviews. Most developers use them comfortably but have gaps in their understanding of how they actually work. Insertion Order Is Guaranteed in Python 3.7 data = {} data [ " c " ] = 3 data [ " a " ] = 1 data [ " b " ] = 2 print ( list ( data . keys ())) print ( list ( data . values ())) Output: ['c', 'a', 'b'] ['3', '1', '2'] Since Python 3.7, dictionaries maintain insertion order as a language guarantee. Before that, order was an implementation detail. This is worth knowing because interview questions sometimes try to catch candidates who believe dictionaries are unordered. Mutating a Dictionary While Iterating data = { " a " : 1 , " b " : 2 , " c " : 3 } for key in data : if data [ key ] == 2 : del data [ key ] Output: RuntimeError: dictionary changed size during iteration You cannot add or remove keys from a dictionary while iterating over it. The safe pattern is to iterate over a copy of the keys: for key in list ( data . keys ()): if data [ key ] == 2 : del data [ key ] Or collect keys to delete first: to_delete = [ k for k , v in data . items () if v == 2 ] for key in to_delete : del data [ key ] Dictionary Views data = { " a " : 1 , " b " : 2 , " c " : 3 } keys = data . keys () values = data . values () items = data . items () print ( keys ) data [ " d " ] = 4 print ( keys ) Output: dict_keys(['a', 'b', 'c']) dict_keys(['a', 'b', 'c', 'd']) Dictionary views are live views of the dictionary. They update automatically when the dictionary changes. This surprises developers who expect .keys() to return a static snapshot. The get() Method Versus Direct Access data = { " a " : 1 , " b " : 2 } print ( data [ " a " ]) print ( data . get ( " a " )) print ( data . get ( " z " )) print ( data . get ( " z " , 0 )) try : print ( data [ " z " ]) except Key

A music generator such as Suno can give a creator a finished track. It does not automatically give them a finished music video. The usual next step is a toolchain: Export the song as an MP3. Use an image model such as Nano Banana to establish the artist, character, location, or visual style. Turn those references into individual video shots with a model such as Veo , Seedance , or another video generator. Route performance close-ups through a lip-sync-capable step when the singer needs to match the vocals. Prepare lyrics or an SRT file, then align captions with the song. Retry failed shots, choose the usable takes, match aspect ratios, place the original track, and compose the final timeline. Upload the exported MP4 somewhere the application can reliably deliver it. Modern multimodal models reduce parts of this work, but an application still has to own the workflow around them. A full song is longer than one generated shot. Character consistency can drift. One failed scene should not require restarting everything. Subtitle timing, task state, retries, cost evidence, and final delivery still need product code. I wanted to see what this integration would look like if the application only had to submit the source material and track one job. For the concrete implementation below, I used the BeatAPI Music Video API . At the simplest level, the application provides: one MP3, WAV, AAC, or M4A file; one to seven reference images; optional creative direction; optional lip-sync and subtitle controls; output format and quality settings. The API returns a task ID immediately and delivers a hosted MP4 when the workflow succeeds. The default path does not require the developer to review or edit a storyboard. Before: song -> reference images -> generated shots -> lip sync -> subtitle timing -> retries -> editing -> hosting Behind one workflow API: audio + reference images + controls -> one async task -> hosted MP4 By the end of the tutorial, you will have a backend flow that: uplo

If you've deployed your application on Render and noticed that emails are not being sent, you're definitely not the only one. I recently faced this issue while deploying my project: https://rizzzler.onrender.com After spending hours debugging my code, checking environment variables, testing SMTP credentials, and reading logs, I finally discovered the real cause: The hosting environment was restricting outbound SMTP connections, preventing my application from connecting to the mail server. To solve this, I moved the email-sending functionality to Google Cloud , where the SMTP connection worked correctly. This article explains how I diagnosed the issue, common mistakes to avoid, and the solution that worked for me. Symptoms You might experience one or more of the following: Password reset emails are never received. OTP emails aren't delivered. Email verification doesn't work. Nodemailer throws timeout errors. SMTP connection fails. Everything works on localhost but fails after deployment. Typical errors include: ETIMEDOUT ECONNREFUSED Connection timeout Greeting never received Step 1: Verify Your SMTP Credentials Before assuming the issue is with Render, verify your SMTP configuration. Check that the following are correct: SMTP Host SMTP Port Username Password Even one incorrect character can prevent emails from sending. Step 2: Check Environment Variables Ensure all required environment variables are configured in Render. Example: SMTP_HOST=smtp.example.com SMTP_PORT=587 SMTP_USER=your-email@example.com SMTP_PASS=your-password Also remember to: Restart your Render service after updating variables. Never hardcode credentials in your source code. Step 3: Test Locally If your application sends emails successfully on your local machine but fails only after deployment, your application code is probably not the problem. This is an important clue. Step 4: Read the Logs Open your Render logs and look for SMTP-related errors. Common messages include: ETIMEDOUT ECONNREFUSED Co

Despite positioning itself as an anti-hookup app, users tell WIRED that Goose has fake profiles, harsh acceptance standards, and problems with inclusivity.

The updates come as Meta and other tech companies are facing scrutiny from regulators and parents around how AI chatbots respond to users in crisis, particularly teenagers.

Colocar los muebles de una habitación es un problema de optimización con muchas restricciones: la cama no va delante de la puerta, el escritorio quiere luz natural, hay que poder circular. Hay un número enorme de disposiciones posibles. RoomCraft AI las explora automáticamente a partir de una descripción en lenguaje natural. El pipeline de tres etapas Parser con LLM: el usuario describe su habitación en texto libre ("un dormitorio de 4x3 con la puerta al norte y una ventana al este"). Un LLM ( Llama 3.1 vía Groq ) lo convierte en una estructura de datos validada con Pydantic : dimensiones, aberturas, muebles deseados. Latencia: <1s. Optimizador con Simulated Annealing: aquí está el corazón del proyecto. Visualización y export: los layouts se renderizan en 3D en el navegador con Three.js y se exportan como plano técnico en PDF con ReportLab . Por qué Simulated Annealing El espacio de disposiciones posibles es combinatorio y lleno de óptimos locales. Una búsqueda voraz se queda atascada en la primera solución "decente". El Simulated Annealing imita el enfriamiento de un metal: al principio acepta movimientos malos con cierta probabilidad (alta "temperatura"), lo que le permite escapar de óptimos locales; según baja la temperatura, se vuelve cada vez más exigente y converge. Es una metaheurística ideal cuando el espacio de soluciones es irregular y no tienes gradiente. La función objetivo puntúa cada disposición de 0 a 100 según ergonomía: espacio de circulación, relaciones entre muebles, acceso a luz y aberturas. El sistema devuelve el top 5 de layouts, no solo el mejor, para dar opciones. Rendimiento Parse: <1s . Optimización: 2–5s . Export PDF: <1s . Footprint en reposo: ~100 MB de RAM. Qué aprendí Que combinar un LLM (para entender lenguaje) con una metaheurística clásica (para optimizar de verdad) es un patrón potentísimo: el LLM traduce el problema humano a uno formal, y un algoritmo determinista y barato lo resuelve mejor —y de forma más explicable— que pedirle

The group is trying to extend its influence beyond Meta.