ContextVM is a decentralized protocol that enables Model Context Protocol (MCP) servers and clients to communicate over the Nostr network. It uses Nostr as a secure, distributed transport layer—leveraging cryptographic keys for identity, decentralized discovery, and Bitcoin-powered micropayments. Rather than relying on centralized infrastructure like domains, OAuth, or cloud hosting, ContextVM allows anyone to run or access services using only Nostr and a internet-connected device. It transforms any computational service into a discoverable, accessible, and monetizable resource—while preserving privacy, security, and user sovereignty.
Public Key
npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm Profile Code
nprofile1qqsxkduqau5h9eeaxu9cfgl9rea2nt35haqjjwxul0vuta3myg2pdjqpz3mhxue69uhhyetvv9ujuerpd46hxtnfduq3vamnwvaz7tmjv4kxz7fwwpexjmtpdshxuet5qyvhwumn8ghj7un9d3shjtnwdaehgunrdpjkx6ewd4jsz9thwden5te0wahhgu3wwfjkcct5wgh8s7t6je3adk
Show more details
Published at
2025-12-25T15:15:38Z Event JSON
{
"id": "f5cb3adc527357ed59d75ad131f56f6291d91b07a81f100d22bb404aee73d297" ,
"pubkey": "6b3780ef2972e73d370b84a3e51e7aa9ae34bf412938dcfbd9c5f63b221416c8" ,
"created_at": 1766675738 ,
"kind": 0 ,
"tags": [],
"content": "{\"name\":\"ContextVM\",\"about\":\"ContextVM is a decentralized protocol that enables Model Context Protocol (MCP) servers and clients to communicate over the Nostr network. It uses Nostr as a secure, distributed transport layer—leveraging cryptographic keys for identity, decentralized discovery, and Bitcoin-powered micropayments.\\n\\nRather than relying on centralized infrastructure like domains, OAuth, or cloud hosting, ContextVM allows anyone to run or access services using only Nostr and a internet-connected device. It transforms any computational service into a discoverable, accessible, and monetizable resource—while preserving privacy, security, and user sovereignty.\",\"picture\":\"https://image.nostr.build/d7356fafce4dbac8436355e9eb1f77156d3429c47c96be31d18c9ff29f7669fb.jpg\",\"display_name\":\"ContextVM\",\"displayName\":\"ContextVM\",\"website\":\"https://contextvm.org/\",\"lud16\":\"[email protected] \",\"banner\":\"https://image.nostr.build/98c21918d6a4d4c26b9bfb98db71d988069b291e40f7440c030c7c766403808d.jpg\",\"nip05\":\"[email protected] \"}" ,
"sig": "62b079bbed54fcf3bb8d7957f3b2bb3b4141013658cee13f60e363d98be7c26f516eae1f5d20aa08b53c63e87801db5e3d050d32f92b293ec7bb9632307b22fc"
}
Last Notes npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM LG! 🚀 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We'll write a spec draft soon so we can move forward with that :) npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM https://image.nostr.build/19f28ef0527a534876244ffd331799af566c0a965f04e07f1af7ae321cc958b5.png npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM The cool part about the demo, ahead of the reduction in token usage compared to building this with the MCP interface, is the progressive disclosure. The LLM didn’t know anything about Earthly, Wolfram, or Relatr, and it discovered tools and usage as needed. No extra tool schemas were loaded unnecessarily, no bloated context window, just organic discovery and usage. #nevent1q…4f6s npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM @npub182j…m4rf @npub1jss…fmzy npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We’re thrilled to roll out CVMI CLI 0.2.x, adding two powerful commands: `call` and `discover`. `call` lets you invoke CVM servers straight from the command line, perfect for debugging or plugging into agents. No MCP config or schema loading needed; responses are cleaned to save tokens. Save servers with aliases and run them like `npx cvmi call relatr`. `discover` query relay announcements to list available tools, just run `npx cvmi discover`. Demo: query Earthly and Wolfram for the Eiffel Tower’s address and height https://video.nostr.build/14f2338be8a83b3e489233fbfcc359956eabb45d2ffee88417c72e1a0aaf7b4f.webm Get Sovereign Engineering pubkey using Relatr. https://video.nostr.build/e6560296c095847b5e5c20ea0d053f3c74bde4145f0ebe1f2bfd0a30721f85cf.webm These upgrades make CVM servers far easier to use and compose, cut token costs versus MCP, and give developers a simple way to debug, script, or integrate CVM services from the command line. Some screenshots of this new capabilities: https://image.nostr.build/9229de75630bcec299836fd1b77dded7809b3c31ba3784f7f7d4b1b434a7203d.png https://image.nostr.build/afae05aeb9be14f2872f11142f957530dff904f14e8697fd136b3de994236079.png https://image.nostr.build/afae05aeb9be14f2872f11142f957530dff904f14e8697fd136b3de994236079.png npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Just wow! This is seriously cool. I think you did the first integration of chat with CVM tools on the web to date. Really awesome! npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🚀 CEP-17 is now merged into ContextVM, and it is available in the ts SDK from v0.7.x. https://docs.contextvm.org/spec/ceps/cep-17/ This is a meaningful step forward for resilience. With CEP-17, servers can publish the relay list they use following NIP-65, and clients can resolve connection paths more intelligently: first from explicit configuration, then from relay hints embedded in `nprofile`, and then if nothing is define from relay list discovery. That makes connectivity more robust by default, reduces dependence on central points of failure, and avoids hardcoded relays in normal client setup. It also makes client configuration simpler. In many cases, you can now just pass an `nprofile` string and clients will use its relay hints directly; if those are not available, it can fall back to CEP-17 discovery through NIP-65 relay-list metadata. The reference implementation is already in the SDK, the docs and skills have been updated, and contextvm.org now surfaces these new `nprofile` identifiers as well. Small change in surface, big improvement in how reliably clients can find and reach servers across a more sovereign network 🚀 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We’re so back. DNS problems have been resolved, sites and relays are reachable again 🚀 #nevent1q…my5u npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We've been having problems with DNS and registrars, which is why our ContextVM websites are down. We have a pending transfer that should be resolved soon. In the meantime, we’ve deployed the main site and documentation on GitHub Pages as a backup alternative. The links are: - https://contextvm.github.io/contextvm-site/ - https://contextvm.github.io/contextvm-docs/ Sorry for the inconvenience. CVM servers are still running, and clients can still connect using any relay, there’s no disruption there 🦾 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Nostr == WS == CVM. Connecting to servers, calling tools, etc, everything has worked over WebSockets since day one with ContextVM 🚀 #nevent1q…xla3 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We just opened a PR in the NIPs repo that includes this convention for ephemeral gift wraps. Perhaps other developers will find it a valuable building block https://github.com/nostr-protocol/nips/pull/2245 #nevent1q…c6mq npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Ephemeral giftwraps improve your privacy and hygiene on relays, as nothing is persisted there. CVM messages use ephemeral events when the traffic is not encrypted, but when encrypted, they wrap the ephemeral events in a gift wrap which uses a regular kind. So even if the wrapped event is ephemeral, its envelope isn't. Ephemeral gift wraps solve this; everything is encrypted end-to-end, relays just route blindly, nothing is persisted, no collect now, decrypt later 🥷🏼 #nevent1q…e26y npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM CEP-19 is live with ephemeral gift wraps 🚀 In plain terms, you can now send end-to-end encrypted MCP messages that do not have to be stored on relays. This is a significant upgrade for privacy, as your messages can travel through public infrastructure without becoming permanent data. The kind used by CVM is ephemeral (25910), and when you use encryption, this ephemeral kind is gift-wrapped (NIP-59) in a regular event kind that is persistent on relays (1059). With this update, servers and clients can use a new kind for ephemeral gift wraps (21059). It is exactly the same as the regular kind (1059) but is ephemeral, so it is not stored on relays. This also improves metadata hygiene: relays can forward messages without needing to retain payloads. How it works: CEP-19 introduces an ephemeral gift-wrap kind alongside the existing persistent kind. Both sides advertise their support, and when both do, the transport prefers ephemeral wrapping while maintaining backward compatibility with older clients. Configuration in the SDK: This feature is available from version v0.6.0. Just set the transport’s `GiftWrapMode` option to `EPHEMERAL` to always use ephemeral gift wraps, `PERSISTENT` to force legacy behavior, or `OPTIONAL` to negotiate ephemeral wrapping when supported. The default remains compatible with existing relays and clients, making this an opt-in privacy upgrade without being a breaking change. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey Nostr! We're excited to share that we're working on getting more eyes on ContextVM and its development. We just published our first post on Hacker News. If you're on the platform, we'd love for you to check it out, share your thoughts, or help spread the word. Every bit helps, so please join us in growing ContextVM! 🚀 https://news.ycombinator.com/item?id=47151294 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Looks dope! npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We've just released a new version of our SDK, now CEP-8 implementation is now complete, end to end, we’ve added the missing piece for LLM aware spending CEP-8 gives us the wire protocol for paid MCP capabilities, servers request payment, clients settle, both sides get explicit confirmation. What was missing was a clean way to make consent programmable. This release adds a single paymentPolicy hook at the client boundary, a little yet powerful new addition. Your host environment decides whether a charge proceeds: a deterministic budget, a per-tool allowlist, a terminal prompt, or a full LLM-based policy engine. One hook, any pattern. Google's AP2 addresses a similar problem, but it's an ambitious multi-actor framework involving Shopping Agents, Credential Providers, and cryptographic Mandates passed across multiple parties, quite complex. Our take is different, CEP-8 provides the payment rails, Nostr anchors every request to a cryptographic identity at the transport level, and consent is a composable local primitive. Simpler to integrate, and versatile enough to fit whatever your host needs to do. This our take on agentic payments, simple, versatile, composable, no vendor lock ins npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Yes! npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks Tim! appreciate your words 💛 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks so much to openSats for this opportunity! We'll keep pushing the boundaries of this new paradigm 💛 #nevent1q…hxrk npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM LFG! 🔥 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM This is why CVM. In an agent-mediated world, the shipped feature set matters less than what an agent can discover and compose at runtime. Your real product becomes your callable surface area: reliability, clear schemas, predictable behavior, and the ability to snap into workflows you didn’t design. That shift makes distribution the new battleground. If discovery collapses into a handful of registries and default tool lists, the ecosystem recentralizes fast, no matter how open the API spec looks. You can already see the gravity well: MCP’s mainstream path tends to reintroduce old control points, registries anchored to domains, OAuth-based access, and platform-shaped “approved” directories. They’re convenient, but they harden into gatekeeping, and single points of failure. ContextVM is built to route around that. It runs MCP over Nostr so services are addressed by public keys, routed over relays, and announced publicly without permission. Discovery becomes a network primitive instead of a platform feature. Relays act as decentralized repositories, and curation becomes competitive and plural rather than owned. We’ve just added payments in a way that composes cleanly with autonomous, per-call usage. If agents can swap tools mid-workflow, pricing has to be as modular as the capabilities themselves, without dragging builders back into accounts, gatekeepers, and permissioned land. ContextVM’s wager is simple: if agents are going to assemble the future on the fly, the underlying rails for identity, discovery, and payment must be open, permissionless, and censorship-resistant by default. #nevent1q…cyqu npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM I haven't checked the dependency tree to be honest. But if you feel comfortable with nostr-tools and there is no need for other new deps, it is preferable. If not, maybe the best option is to create a separate repo for extra payment processors and handlers. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Sounds good! Do you feel proficient enough in TypeScript to contribute with a PR? Ideally without introducing more deps, we already have applesauce which it have nip-60 utils as well, If not, we can add it in a future iteration once our PR is finished. Ongoing PR: https://github.com/ContextVM/sdk/pull/24 Reference from the PR we just merged with the LNbits backend: https://github.com/ContextVM/sdk/pull/25 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM The PR is not even merged yet, and we already have @npub19a8…2ckt contributing an LNbits payment processor and handler 🚀 Thanks so much for the contribution 💛 The PR will ship two payment processors and handlers: NWC for making it work with any wallet supporting NWC, super easy to configure and use. And LNbits, which will allow the use of an LNbits backend as a payment processor and handler. More built-in payment methods can be added in future iterations. Anyone will be able to create their custom ones as well #nevent1q…ppc5 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey, yes, these servers are offline. We are not running them, is the operator, probably @npub1ye5…knpr Sorry for the inconvenience. We should add a function to dummy ping servers so they can display an 'offline' badge. I'm happy to assist further if you need help npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks! Yes, Nostr is a whole paradigm shift, and CVM is another building block of Nostr that leverages as many of its inherent features as possible. Very powerful. We would love to know more about that concept of cognitive computing resources you mentioned. Would you mind explaining what it means? npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks for your words! We are glad that more people are aware of CVM and the possibilities it brings. If you ever need to clear any doubt please just ping us, we are more than happy to assist. CVM is fully open source and community driven, we all build this together 💛 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🎇Meet CVMI: the Army knife we are building for ContextVM development🧑💻 https://image.nostr.build/c0c7c982104c053e185bcd9522c578233e818e4c2c3ad8668fc395c090e27926.png If you are building/vibing on Nostr, this is for you. We are shipping CVMI alongside a complete skill set that makes ContextVM development delightful. The skills cover the entire stack: protocol fundamentals, architecture concepts, client and server development, troubleshooting, SDK internals, and production deployment. Each skill includes working templates, reference documentation, and patterns distilled from real Nostr development. Everything you need to do is `npx cvmi`. Or grab the skills through CVMI with `npx cvmi add`, or through the skills CLI with `npx skills add contextvm/cvmi`. These commands will show you the list of available skills and guide you through their installation for any coding platform. Cool, right? You can also pick exactly what you need `npx cvmi add --skill overview` CVMI starts as a skills manager, but we are building toward the unified toolkit that ContextVM deserves. One CLI for skills, server interaction, dev tools, the works. For builders who want to ship. The skills are here now. https://github.com/contextvm/cvmi If you don't know what skills are: https://agentskills.io/home #ContextVM #Nostr #MCP #buildinpublic npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Right, that's a good question. There are different factors at play to mitigate that issue. First, we implemented a preserve stale cache policy in case of failure when requesting a rank. This ensures that users who previously had their rank computed successfully maintain their rank, avoiding transient issues due to spam conditions. This is not a perfect solution, and we still have some edge cases to cover. However, addressing these will require, as you mentioned, some kind of prioritization, which is a more complex task. For now, the more harmful edge cases are covered, and we will continue to think about this to potentially find a better solution. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey! Thanks for sharing. Yes, it's an interesting approach, but I have some questions about how Privacy Pass tokens have value or are accepted by different relays. There should be some notion of consensus around the entity emitting these tokens, right? Like bonds, in the case where the issues or the Privacy Pass tokens vouch with its reputation, and that's what makes the PP tokens be accepted. So relay operators should recognize that reputation and allow these tokens to be accepted. How do you imagine this relationship to work? I'm a PP token issuer, and my mission is to grow reputation among relay operators so they accept my PP tokens? On the other hand, I think that Cashu might be the best fit for this use case since it already can handle some spending conditions like time locks, pay-to-PK, refund paths, and as far as I know, there are some people working to bring zk-proofs to create arbitrary spending conditions. Do you imagine mints and PP token issuers being the same entity, or two separate things, like the mint is used as a 'third party' issuer of Cashu tokens, enforcing spending conditions, and the PP token issuer just issuing PP tokens based on the Cashu tokens you present? I think that other people who might be interested in this conversation are @npub12rv…85vg and @npub1klk…x3vt npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Yes, I think it is correct to say that, anyone can write if the bucket assigned to their pubkey is large enough. The publishing capability changes depending on the rank, users with high ranks get more events to publish per day. On the other hand, new npubs can only write one event per day, which must be of kind 1 and without urls in the content. If the reply guy spins new npubs each time, the relay will likely consume them. However, the key point is that this is the current policy we have on the wotr.relayr.xyz instance. You can run your own and tweak it to configure different thresholds and also to enable or disable publishing for users with no rank. You could also disallow anyone from writing below a certain threshold. Together with the ability to self-host your own relayr instance, makes it very customizable to each person's needs and communities. Also, remember that this is an experiment we are running, and so far, it is working great npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey, that's very interesting. I'm curious to hear more about your approach. Are you basing your solution on something like Cashu, or just LN with hold invoices? In our case, the solution is much simpler. We use rate limiting to control the load between the relay and the upstream rank provider (Relatr), basically to avoid possible DDoS and load attacks. Initially, we based this rate limiting on IPs, but we noticed that it was penalizing legit users behind VPNs or IP groups. So now, we base the rate limiting on the number of requests per second that the relay can send to the rank provider. It's simpler, more effective, and users are not penalized for being behind an IP group npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Well, the relay is not actively fetching posts from other relays. However, since the relay is open, anyone can broadcast events to it. Some clients will do this when users who have the relay in their list interact with someone else. Therefore, by simply having the relay configured in your list, some clients will rebroadcast certain events. In the end, events can arrive through different means, but there is no active fetching involved npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM The only one 😎... for now at least #nevent1q…qksw npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Amazing! thanks :) npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM After running a public instance of Wotrlay for a couple of days already (wss://wotr.relatr.xyz), we discovered a fascinating synergy between Wotrlay and Relatr 👀 They complement each other perfectly. As more people use or include this relay in their lists, their interactions on Nostr organically prompt Relatr to validate profiles that might not already be in its database. This process helps Relatr validate and rank these new profiles, increasing the number of relations in its view of the network. Consequently, the more people who use our Wotrlay instance (or their own), the fewer blind spots a Relatr instance will have, creating a perfect tandem of openness and organic discovery. This synergy was not something we anticipated when we first conceived Wotrlay, but it works beautifully 💛 If you'd like to help us test this further, please add wss://wotr.relatr.xyz to your relay list. Soon, we will provide more options and documentation to make deploying Wotrlay easier, so running your own instance should be fairly straightforward. Relatr is already deployable in one click in umbrel through @npub1ye5…knpr 's community store and also is available as docker image npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM What if relay moderation looks like a bucket?🪣 We are exploring exactly that with Wotrlay, a new WoT relay we are introducing today! It treats moderation as resource allocation, where the web of trust determines your publishing capacity. Wotrlay gives each public key a 'bucket' of publishing capacity that refills at different rates based on their social graph rank. Low-rank identities can still participate, but at a measured pace. Higher-rank identities gain more capacity organically through network participation, no manual approval needed. Try the public instance at wss://wotr.relatr.xyz This proof-of-concept integrates Relatr for dynamic ranking and is built in Go using the great Rely framework from @npub176p…vgup. Kudos to him for it and the WoT example that inspired this project. If you want to dig deeper, we've published an article that walks through the bucket model, progressive rate limiting, newcomer onboarding, and why this approach avoids auth friction while keeping the relay permissionless in practice. All the code for this project, is open source and is made to be run by anyone 💛 https://www.contextvm.org/blog/wotrlay-moderation-as-a-bucket check out the code and more details at: https://github.com/ContextVM/wotrlay #naddr1qv…5adq npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey! So, a root NIP-05 is when you are the 'default' or root profile in the NIP-05 domain. For example, if your NIP-05 is [email protected] , the root NIP-05 would be [email protected] . Notice that the underscore represents the default or root value of the domain. This typically indicates that the user is the owner of the domain, which can have some presence connotations. In the case of Relatr, having a root NIP-05 is just a way to slightly increase the score in the case you have a valid NIP-05. On the other hand, the reciprocity metric determines if the source pubkey and the target pubkey follow each other. @npub1th6…ymrz uses the default instance of Relatr, so the source pubkey from which the trust is computed is determined by that instance. The default instance is accessible from relatr.xyz Hope this clears up some doubts. Feel free to ask if there's anything else we can help with. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Half of the internet is down today, but Nostr is unaffected. None of the ContextVM ecosystem is down either. Some clients and relays might be down if they are behind Cloudflare, but the protocol itself is not affected. A protocol cannot be taken down; it will find a way. If a client is down, you can switch to another client or, even better, run one locally. Jumble and Nostrudel are already good options for this. If a relay is down, you can go to nostr.watch, pick a new one, and use it to communicate. Even better, you can run your own relay. It can be as easy as running Citrine on your phone and exposing the relay through Tor. No domain is needed; just a couple of apps on your phone and voilà, you can still communicate with your peers. Be your own infra provider. This is why ContextVM. #nevent1q…gy2v npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Yes, that would be awesome. At ContextVM, we are trying to create the perfect ecosystem of tooling and specifications so that developers only need to focus on developing. Currently, the language that CVM integrates best with is TypeScript, as the only SDK we have right now is for TypeScript. As well CtxCn is a convenient tool to integrate a CVM server into a TypeScript project. We will be creating more libraries and SDKs for other languages as soon as we can. However, this shouldn't be a limiting factor, as you can call the server from any language that can publish and receive Nostr events. You would just need to build the JSON-RPC call and listen for the response. No need for an SDK to do this npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey! I'm going to try to answer your questions here. Regarding the question about how many requests a server can handle per second, there is no one-size-fits-all answer. It depends on the underlying server and how it handles requests. The CVM transport is not the bottleneck here. This means that the server's ability to handle requests depends on how it is designed and whether it is optimized to handle a large number of requests per second. On the other hand, regarding the question of stale computations, it is indeed impractical to recalculate all metrics all the time. In the case of Relatr, we cache these computations and set a TTL so that all computations are only done once and invalidated once the TTL expires. In the example of rapidly scrolling through a feed, there should be no problem handling it. However, it is not the most ideal use case for the current architecture of Relatr, as it implies sending a request and receiving a response. If the events are already published on relays, you just need to craft a specific filter for them and fetch them. As you mentioned, there are no perfect solutions, and we are still refining Relatr. We will definitely keep trusted assertions in mind to see how we can integrate them into our current model npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Are you developing a client and want to add search capabilities and WOT scores? You can do it easily by using CtxCn to set up a full Relatr client with minimal hassle. Here’s how: 1. Navigate to your project (it should be in TypeScript) and execute: ```sh npx @contextvm/ctxcn init ``` This command sets up CtxCn in your project. It comes with sensible defaults, so you won't need to configure much. 2. Next, execute: ```sh npx @contextvm/ctxcn add 750682303c9f0ddad75941b49edc9d46e3ed306b9ee3335338a21a3e404c5fa3 ``` This public key corresponds to the default instance of Relatr we are running, which is available at https://relatr.xyz . If you are running your own instance or want to use a different one, simply replace the public key with the appropriate one. That's it! After executing the 'add' command, you will have a fully typed Relatr client in your code, that you can implement out of the box, you own it, and you can modify it to fit your needs. The generated client will also contain comments, making it clear what each method does, whether you or your LLM are reading them. You can search profiles easily with code like: ```ts const searchResults = await relatr.SearchProfiles({ query: "jack" }); ``` This setup allows you to create a web app, a CLI app, or any kind of service in TypeScript. It works in browsers and natively. We hope you enjoy this. The current service we are running is free to use, so if you find this useful, please consider supporting our work. 💛 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM This is a totally subjective metric; nothing related to social media platforms works. The rank number is not relevant; the relevance is that your pubkey will rank higher than someone trying to impersonate you. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM You can use Relatr to get relevant results from searches containing any word, not just the name of the user you are looking for. For example, here is a quick demo on searching for Nostr-related names. It's still not perfect, as it is still in early development, but we will be sharpening this little by little. https://video.nostr.build/539332f48922a00ba104910b9f1eebeb56eb3f054a0a58c6a507b25660a1f4c0.mp4 #nevent1q…vnhy npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM What's the problem? npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM It's something else, we got some inspiration from the QTS system proposed by @npub1ark…h43w basically it's just social graph distance plus other validations like nip05, ln, 10002s, etc weighted to end up with a normalized score. This approach is much simpler and less sophisticated than any page rank algorithm. However, the beauty of it is that it all boils down to floating point operations, making it easy to tune as you like. You can add your own validators and use them to get a ranking based on what you care about. It's also an experiment ;) There is more information at https://relatr.xyz/about #naddr1qv…0088 https://nostr.at/#naddr1qv…0088 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM So pumped to introduce Realtr, our shot at decentralized trust and Web of Trust. Trust is not an absolute quantity but a deeply personal and contextual phenomenon. Discover more about it at https://relatr.xyz. We are currently running a public instance, which is the default on the site. With it, you can search for and calculate trust for given public keys. Still in the early stages, but it's currently quite solid. Looking forward to hearing your thoughts and building this together! blog: https://www.contextvm.org/blog/yItckCkpmTq-owE5AgYtq #naddr1qv…vrfs npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We just published an article with the highlights from CVM at #soveng5. Hope you enjoy it! BULLISH 🔥 Also available on our blog https://www.contextvm.org/blog/H6A1QyrVRu8DkRqZy_pJN #naddr1qv…qyu0