Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

The beauty of sync engines: ๐Ÿ“ update on one client ๐ŸŒ HTTP POSTs to API server ๐Ÿ—ƒ๏ธ API updates the DB ๐Ÿ“œ DB feeds changes to WAL (write ahead log) ๐Ÿ” sync engine picks up WAL and feeds data to subscribed clients ๐Ÿ’ป long polling clients update their own...

64,390 Aufrufe โ€ข vor 1 Jahr โ€ขvia X (Twitter)

12 Kommentare

Profilbild von Kyle Gill
Kyle Gillvor 1 Jahr

Why this is cool: - a single generic endpoint akin to a /graphql POST (define the schema, stuff just worksโ„ข๏ธ) - the server is still the source of truth in the DB - there's no loading status on the data, no Promise (ie no loading spinners) - multiplayer for free

Profilbild von Wonderchat
Wonderchatvor 2 Jahren

Automate up to 70% of your customer support today. Save time and help your users find answers quickly. Try now at

Profilbild von Zach McQuiston
Zach McQuistonvor 1 Jahr

But what if โœจeverything was database โœจ

Profilbild von Kyle Gill
Kyle Gillvor 1 Jahr

This demo is super cool! Love the concept of just dissolving everything away to run in the database server. Feels like it's the eventual end state of everything

Profilbild von jensen
jensenvor 1 Jahr

Built this one with sqlsync Can try it at

Profilbild von Kyle Gill
Kyle Gillvor 1 Jahr

Will definitely look into it!

Profilbild von Blake Rouse
Blake Rousevor 1 Jahr

Every other week we toy with the idea of starting an electric migration hahaha

Profilbild von Kyle Gill
Kyle Gillvor 1 Jahr

Haha yeah I need to wait until a stable release before I deal with another migration ๐Ÿ˜‚

Profilbild von Cruz
Cruzvor 1 Jahr

R u using zero

Profilbild von Kyle Gill
Kyle Gillvor 1 Jahr

This is Electric + Tanstack optimistic

Profilbild von whos your daddy
whos your daddyvor 1 Jahr

What are the advantages to this over an API writing to a WAL? Wouldn't this tightly couple your DB design to your business logic or is that not a big deal?

Profilbild von Kyle Gill
Kyle Gillvor 1 Jahr

The DB maintains the ACID rigamarole and queryability that a normal app benefits from so you can decide what things to sync I think is the idea. If a table doesn't need to be synced live you can still query it just fine but they run on the same pipes.

ร„hnliche Videos

This is a standard practice for almost all Tier-1 banking applications in Nigeria, and for some fintech applications Iโ€™ve previously performed pentests on. Client-side encryption isnโ€™t a total waste, or a waste of compute, as some people have claimed, but rather a measure to protect against API tampering or API request/response manipulation between the client and the server when implemented properly. Even with HTTPS, attackers can capture a decrypted version of web or mobile API data in transit because the browser and the server establish a level of trust during the TLS handshake. Attackers can leverage this trust to capture & proxy already-decrypted traffic, tamper with it, and then forward it to the server. This allows them to override what the user interface or client is originally supposed to send and replace it with data of their choosing. That is why validation needs to be performed on both the client and the server side. To wrap up, encrypting API requests and responses makes it significantly harder for attackers to tamper with data, even if they capture the traffic, unless they have access to the encryption details (algorithm, encryption mode, key size, secret key, and initialization vector), assuming asymmetric encryption is used. In the demo below, you can see how I discovered additional parameters (balance, is_admin) in the API response, captured the registration API request, despite it being sent over HTTPS from the interface, added the discovered parameters, and successfully inflated my balance to 50 billion and also escalated my privileges to admin, and ultimately deleted the accounts of two live users/customers. In the second slide, I captured an API traffic of a bank app, and you can see how difficult the payloads are to read.

Ghost St Badmus

217,804 Aufrufe โ€ข vor 8 Monaten

New course: MCP: Build Rich-Context AI Apps with Anthropic. Learn to build AI apps that access tools, data, and prompts using the Model Context Protocol in this short course, created in partnership with Anthropic Anthropic and taught by Elie Schoppik Elie Schoppik, its Head of Technical Education. Connecting AI applications to external systems that bring rich context to LLM-based applications has often meant writing custom integrations for each use case. MCP is an open protocol that standardizes how LLMs access tools, data, and prompts from external sources, and simplifies how you provide context to your LLM-based applications. For example, you can provide context via third-party tools that let your LLM make API calls to search the web, access data from local docs, retrieve code from a GitHub repo, and so on. MCP, developed by Anthropic, is based on a client-server architecture that defines the communication details between an MCP client, hosted inside the AI application, and an MCP server that exposes tools, resources, and prompt templates. The server can be a subprocess launched by the client that runs locally or an independent process running remotely. In this hands-on course, you'll learn the core architecture behind MCP. Youโ€™ll create an MCP-compatible chatbot, build and deploy an MCP server, and connect the chatbot to your MCP server and other open-source servers. Hereโ€™s what youโ€™ll do: - Understand why MCP makes AI development less fragmented and standardizes connections between AI applications and external data sources - Learn the core components of the client-server architecture of MCP and the underlying communication mechanism - Build a chatbot with custom tools for searching academic papers, and transform it into an MCP-compatible application - Build a local MCP server that exposes tools, resources, and prompt templates using FastMCP, and test it using MCP Inspector - Create an MCP client inside your chatbot to dynamically connect to your server - Connect your chatbot to reference servers built by Anthropicโ€™s MCP team, such as filesystem, which implements filesystem operations, and fetch, which extracts contents from the web as markdown - Configure Claude Desktop to connect to your server and others, and explore how it abstracts away the low-level logic of MCP clients - Deploy your MCP server remotely and test it with the Inspector or other MCP-compatible applications - Learn about the roadmap for future MCP development, such as multi-agent architecture, MCP registry API, server discovery, authorization, and authentication MCP is an exciting and important technology that lets you build rich-context AI applications that connect to a growing ecosystem of MCP servers, with minimal integration work. Please sign up here!

Andrew Ng

142,234 Aufrufe โ€ข vor 1 Jahr

Anthropic won't like this open-source repo. It is going to cost LLM providers a lot of money. Every CI run of an AI app today sends real requests to providers like OpenAI or Anthropic. Like any other LLM call, this too gets billed at actual API rates. So for teams with high commit volumes, this accumulates into a meaningful chunk of API spend. One common hack devs use is that instead of invoking the LLM API, the test calls a fake local server that speaks the same API and returns a dummy response. The catch is that the dummy response is a copy of what the provider returned on the day it was saved, and providers keep adding fields and changing types. So the tests keep passing against a schema that's no longer valid, while the real integration breaks in production. A smart approach is now actually implemented in CopilotKit๐Ÿช's recently open-sourced aimock project. Every day, the repo's own CI sends a handful of requests to the real API and the same requests to the fake server, then compares both against the official client library's type definitions. Those are the only real API calls in the whole setup, and they run on the repo's own keys, not in anyone else's CI. A single team can push hundreds of commits a day, and thousands of teams are already doing that with coding agents. All of those runs stay offline, because one repo checks against the real API on everyone's behalf. When a check fails, a coding agent updates aimock's built-in response schema, the full test suite has to pass, and a patch version ships to npm. By simply upgrading the package, the corrected schema gets reflected in every project using it. The capability is not just limited to a single provider. The same server works for Claude, OpenAI, Gemini, Bedrock, Azure, Ollama, plus MCP tools, A2A agents, AG-UI event streams, vector DBs like Pinecone and Qdrant, and search, speech, image, and video endpoints. Here's the repo: (don't forget to star it โญ) That said, mocking your API calls is one thing. AI engineers should also know how to test agents properly in the first place, which several teams still skip. I wrote a full walkthrough on that, covering build, testing, evals, tracing, and deployment. Read it below.

Akshay ๐Ÿš€

62,821 Aufrufe โ€ข vor 23 Tagen

We gave an AI agent its own wallet and a job. Then we tried to rob it. Meet the Casper Agent Simulator: an AI analyst paying its own way over x402 on Casper, powered by ChainGPT. Right now AI agents can't buy anything on their own. Every API wants a human to sign up, hand over a card, and babysit the keys. The whole internet runs on subscriptions because charging half a cent was never worth the payment fee. We built a demo to show what happens when that changes. Meet Caspi. She's an AI research analyst with a Casper wallet, an era allowance, and a client who wants a market briefing. She buys her own inputs, one request at a time: โ†’ live CSPR market data โ†’ two headlines from ChainGPT's AI News API โ†’ one ChainGPT LLM call for the analyst take โ†’ a second of compute to compile it Every purchase is a real HTTP 402. The stall quotes a price, Caspi signs an x402 payment payload, the server verifies it and hands back the goods with a settlement receipt. Around 8.5 CSPR of micropayments become a finished briefing. No signup, no card, no API key. What Casper brings to it: โ†’ Fixed 0.1 CSPR fees, so tiny payments actually make sense โ†’ Zug finality, settled in one block, no reversals โ†’ Smart-account guardrails: era spend cap, per-payment ceiling, endpoint whitelist, verifiable identity (caspi.cspr) That last one is the good part. You can fool an AI agent. You can't fool its account. So there's a "try to rob the agent" panel. A 4,800 CSPR fake NFT. A phishing invoice. A shady endpoint. A thousand-payment drain. Every one of them bounces off a rule the chain enforces. Losses: 0.000 CSPR. The whole thing was lab-coded with the ChainGPT Claude Code skill. One prompt scaffolded the x402 server, the signed-payment client, the live news and LLM integration, the guardrail logic, and the entire 8-bit agent floor. What used to take a team a sprint now takes a prompt and an afternoon. Install: /plugin install ChainGPT-org/chaingpt-claude-skill Anyone can build on Casper with ChainGPT!

ChainGPT

55,142 Aufrufe โ€ข vor 1 Monat