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
nprofile1qqsxkduqau5h9eeaxu9cfgl9rea2nt35haqjjwxul0vuta3myg2pdjqpz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dsvynql7
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 Introducing CEP‑22 (WIP). This new spec adds a simple way to transport ContextVM messages that exceed the relay size limit. It proposes fragmenting a single payload into chunks across multiple events and reassembling it once the receiver has collected all the chunks. The design stays narrow, just enough to handle larger tool results while preserving the current workflow. See the draft spec: https://github.com/ContextVM/contextvm-docs/blob/feat/larger-than-relays/src/content/docs/spec/ceps/cep-22.md npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Curious about which services are already leveraging ContextVM? On our website you can find a list of public server to which your AI agent can connect through our infrastructure! 👇🏻 https://contextvm.org/servers npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks 💛 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM In today’s update we cover the latest news from ContextVM. In particular, we have been chosen to mentor the next generation of open-source contributors through the Summer of Bitcoin internship program 🚀 We also cover our latest modification to the CVM website and the spam attack that recently hit our relays. Read the full article to learn everything going on in the CVM World! https://contextvm.substack.com/p/mentoring-the-next-generation-the #naddr1qv…gz9c npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We bring amazing news! ContextVM has been invited to participate in the Summer of Bitcoin program. https://www.summerofbitcoin.org/ This is a global, online summer internship program focused on introducing university students to Bitcoin, Nostr, and open-source development and design. We’re very glad to have been chosen as mentors. We’d also be grateful to hear your project ideas for a student to work on for ContextVM during the summer. Please share any you have. What would you like to see in ContextVM? npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Basically we replaced the relay we were using with Strfry and hardened some writing rules. Strfry also has some sane abuse protection out of the box. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Lazy yet productive Saturday. Stabilized relays from the spam attack and forked Strfry during the process. Contributed to https://ants.sh by @npub1der…xzpc to add relatr for search capabilities. Touched grass npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM This should be fixed now 🫡 As a side effect, we forked Strfry to add a convenient way to deploy a relay and some write policies to harden it for CVM usage. https://github.com/ContextVM-org/strfry-cvm #nevent1q…0mym npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hmm, what is your Node version? Some older versions might not have ws defined globally. In any case, we just pushed a new version of cvmi that polyfills this. Please test 0.2.6 and let us know, your feedback will be greatly appreciated 🙏 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🕰 New public server available! 🕰 This is an OTS client that lets you easily Open Time Stamp any Nostr event. The usage is straightforward: two tools, 'ots_event' to create an attestation for an event, and 'verify_ots', which lets you verify the OTS attestation and its state in the time chain. With this server, you or your agents can easily OTS any Nostr event. Here’s a brief demo: https://video.nostr.build/74e0a7eaebda78e3ae27c48b53adfbdac71efa2da606fcb665fa496460aa8cfb.webm The project’s code is open source, and you can run your own instance if you wish. By default it uses public Bitcoin nodes to verify the attestations, so you don’t need to run your own node. https://github.com/ContextVM-org/ots-cvm Server page: https://www.contextvm.org/s/e1c1c32729cbd542c9b9ce7ee6e421c434e07835228020c4f57140782f02496a You can use this service for free, but public OTS servers need to cover operating costs. If you’d like to donate, please refer to opentimestamps.org. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🌍 New issue of the ContextVM world newsletter 🌍 In today’s update we cover CEP‑17, the latest specification change to the CVM protocol. This change allows MCP servers to announce the relays for establishing connections, making it easier for clients to discover them. We also discuss new CVMI capabilities and other news from the ecosystem, plus demos and a new Rust SDK that is currently being built. Hope you enjoy it! Don’t miss any issue, subscribe to our Substack. https://contextvm.substack.com/ #naddr1qv…z2d5 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 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 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 Roughly 16 users, we are observing common relays to determine how many people have added wss://wotr.relatr.xyz to their relays list. To do this we are using nak with the following command, you can check it on your end as well. ''' nak req -t r=wss://wotr.relatr.xyz -k 10002 wss://relay.damus.io wss://nos.lol wss://relay.primal.net wss://bitcoiner.social wss://search.nos.today/ wss://nostr.mom/ wss://relay.snort.social/ wss://discovery.eu.nostria.app/ wss://nostr.wine wss://eden.nostr.land | wc -l ''' 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 In today's release of wotrlay, we included special treatment for these kinds plus 0, 3, and 10002s. This allows them to be accepted without rate limits, also, the current version of relatr already enables you to set extra relays for publishing the TA events it generates, which are 30382s. We have already configured our public instance to publish to your relay and the wotrlay instance we are running as well 🦾 plus user outboxes ofc npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🚀 wotrlay v0.2.x is here As wotrlay matures, we've identified and addressed edge cases where transient issues could temporarily affect user buckets. Timeouts, rate limits, and network conditions sometimes caused the relay to handle cache refreshes less gracefully than intended, which could result in users being downgraded when they shouldn't have been. v0.2.x resolves this. The relay now preserves cached rank data when encountering these edge cases, ensuring users can continue publishing without issues. We've also replaced IP-based rate limiting for rank lookups with an approach that no longer penalizes users behind VPNs, and improved response handling to be more robust under real-world conditions. We've also added a special condition for event kinds 0, 3, 10002, 10040, and 30382, which are now always accepted and are not affected by the rate limiting of the bucket algorithm. For operators: just upgrade. For users: your posting ability now stays consistent regardless of previously unhandled edge cases. Docker builds are leaner and faster too. Building reliable WoT infrastructure means continuously observing, fixing, and improving. v0.2.x represents that ongoing commitment 🫂 #nostr #wotrlay #wot npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Valid nip 05 addresses like [email protected] npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Fully free and open source. You can find it and use it at relatr.xyz , you can also integrate it in your client. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM I don't understand what you mean exactly. In this project, spam is mitigated by each one's bucket. By NPS, do you mean Net Promoter Score? npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM It is more a classic bucket, it adds tokens at a constant rate until capacity is reached. Requests consume tokens when available. There is a full analysis of the current implementation here https://github.com/ContextVM/wotrlay/blob/master/wotrlay-v2-analysis.md . Thanks for the suggestion anyways! 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 Happy Christmas! Thank you to everyone for accompanying us this year 💛 We have a little, yet special gift for you. We revamped our website. It was functional, but lacked content and a better design. Now you can find much more information, contact details, and all the links to navigate the ContextVM ecosystem, learn more, build, or participate. We take advantage of this opportunity to also make a slight modification to our logo. We hope you like all of this. We want to make ContextVM a great ecosystem of freedom tech where everyone feels welcome and supported, and part of it is to make it beautiful. Committed to open source. Let's keep building! 🫡 Visit: https://www.contextvm.org/ If you have any feedback, we would love to hear it! https://image.nostr.build/fa63b7404873b76ca6775438228aa2b9c0256d60bfb55cba7294fa0bd968f6ce.png npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🚀 CVM SDK v0.1.47 has landed! 🌟 This release packs a punch with improved reconnection handling. Previously, if a relay used by a client and a server experienced a prolonged outage (minutes or hours), the apple-sauce relay handler would fail to publish new messages after the relay came back online. With this update, clients and servers automatically handle this, resubscribe and resume event sending as soon as the relay is back online. Server operators, don't miss out, update to the latest SDK version for a smoother, more reliable experience. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Performing some maintenance on our public relatr instance, sorry for the inconvenience. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM @npub1jss…fmzy is Super Based 🌩 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM BIG PLANS! #nevent1q…apnv npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🎇The awesome CVM repo is growing! Three new servers have been added in the past few days. They are: - Nanalytics (https://github.com/humansinstitute/nanalytics): Website analytics like your Nanna used to bake. Over Nostr, privacy-preserving, simple analytics, easy to host. - Earthly Geo Server (https://github.com/zeSchlausKwab/earthly/tree/master/contextvm): A server focused on geocoding and reverse geocoding via OpenStreetMap Nominatim. Features search_location for forward geocoding and reverse_lookup for coordinate-based place metadata. - Wavefunc Music Metadata Server (https://github.com/zeSchlausKwab/wavefunc/tree/main/contextvm): A server for radio stream metadata extraction and MusicBrainz lookups. Features extract_stream_metadata for Icecast/Shoutcast streams and musicbrainz_search for detailed track information. The Geo Server and the Music Metadata Server are also public and are already integrated into earthly.city and wavefunc.live. They are accessible and can be used through the Contextvm website as well. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🚀ContextVM SDK version 0.1.41 is now available with significant improvements to transport integration, relay handling, and async architecture. Key new features include optional client public key injection in MCP requests, enabling better server integration and authentication capabilities. This feature, documented in CEP-16, allows server transports to inject client public keys into request metadata when configured with `injectClientPubkey: true`. Learn more at https://docs.contextvm.org/spec/ceps/informational/cep-16/ The release also brings robust relay reconnection for Nostr server transport, fixing relay restart issues in ApplesauceRelayPool with comprehensive reconnection tests. This ensures more robust operations in long lived servers. Performance improvements come from async architecture enhancements including a TaskQueue utility for non-blocking event processing, parallel transport startup operations, LRU caching for session management, optimized authorization lookups, and improved notification broadcasting with backpressure handling. These changes deliver better integration between transports and underlying servers, more reliable relay handling, and enhanced performance through optimized async operations. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🚀 Exciting news! We're working on a new CEP for ContextVM: Common Tool Schemas! 🌐 https://github.com/ContextVM/contextvm-docs/issues/15 Imagine a marketplace where users can choose the best server for their specific needs, without being locked into a single provider. That's the vision behind our new CEP! With Common Tool Schemas, we're enabling interoperability between clients, allowing users to discover equivalent services, switch providers seamlessly, and compare offerings based on quality, cost, or trust. This is the original idea behind DVMs, where users announce a desired output and service providers compete to fulfill the job requirement in the best way possible. 🔧 Key features: - Reference server pattern for canonical tool schemas - RFC 8785 JCS for deterministic hashing - CEP-6 announcements for discovery We'd love to hear your thoughts and opinions on this proposal! Share your feedback and help us shape the future of ContextVM. You can just share your thoughts in the comments of this note, or in the issue #ContextVM #CEP npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Veo que ya has encontrado algo de informacion, no dudes en preguntar! npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Today, we are releasing Relatr v0.1, featuring significant architectural improvements powered by the new Nostr Social Duck library. This update addresses critical scaling challenges and makes running your own trust engine more accessible than ever. We have written an article that delves into the details of this new release and provides other useful resources. We hope you enjoy it as much as we do 💛 #naddr1qv…qanw npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM In Relatr, we use the relations within the following list as well, aka social graph distance. The difference is that we focus on a trust model that always starts from the perspective of a source pubkey. This is because in decentralized networks like Nostr, there is no global state or a way to compute a global trust score. Our approach is to embrace this and accept that trust is a social phenomenon that occurs between the relation of two profiles: a source and a target. This means that what might be trustworthy for you may not be for me, and this is the only feasible approach we found that might work, as the idea is that everyone can run their own Relatr instance setting yourselve as the source. In the other hand, the insight that led us to choose this approach is that if you trust the source pubkey from an specific Relatr instance, you can in some way extend your trust to what the source pubkey trusts. The analogy would be: if I trust you, I can trust what you trust. So, even though the trust is always computed from a source pubkey, if you trust the source, the score would still be meaningful for you. There is more information on the Relatr.xyz page in the About section. We also wrote an article when we introduced Relatr, going through the rationale behind our approach. Hope this helps! npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey! We just answered this a moment ago. Just keep in mind that Relatr is about relative trust score, so it's going to always be determined by the source pubkey. The idea is that the actual value of the trust score doesn't matter that much. It doesn't matter if you have 100, 95, or 50. The important part is that it's easy to determine if there are impersonators of you, so it's easy to determine who is the impersonator or the real one. #nevent1q…uu65 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM De nada ;) 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 This is another awesome example of the possibilities that bring contextvm. Easily deployable analytics for your page, with no more dependencies on evil corporations that harvest your data. Reclaim your sovereignty, and have fun along the way, it has never been this easy #nevent1q…8wrd npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🚀🚀 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 #nevent1q…n0my npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM The approach we could take with CVM is to leverage the native notification system that MCP has built in for asynchronous and long-running jobs, which I believe fits this use case. MCP also has the concept of resource subscription, allowing you to subscribe to changes in a specific asset exposed by the server. For example, you can subscribe to 'hello.txt', and if the document changes, you receive a notification indicating that the resource has changed. However, for this specific case, I think regular notifications would suffice. Here's how it would work: If the CI runner is behind a CVM server, the git client or any authenticated user can send a call to a tool named 'run_ci' (for example). Inside the json rpc object representing this call there is a 'progresstoken' value set by the client calling the tool, which the server then uses for correlation. Once the tool is called, the server streams back progress notifications, embedding the same 'progresstoken' defined by the client. This is how correlation works in MCP. The server can then send all the notifications generated during the process and end with a final response, which is the result of the runner. We have been experimenting with this stream-based approach, and it already works out of the box in CVM. It is also bidirectional, allowing the client and server to exchange messages within the context of a tool call execution. This effectively enables reconciliation protocols with 'need' and 'want' states, similar to what Git or even negentropy does under the hood. 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 This is quite cool! Why limit yourself to a single WoT provider when you can use multiple and present the results? The more perspectives, the better. After testing Profilestr, we noticed that Profilestr, Vertex, and Relatr tend to output very similar scores, with only slight variations. This indicates that they are quite solid, even with different approaches to compute the trust scores. Relatr and Vertex can be used without leaving the nostr. Relatr uses CVM, Vertex uses a DVM-like API, Profilestr offers a REST API endpoint, so there's no excuse not to integrate some of these options into your client. Fight spam, protect your users from impersonators, and increase the value. #nevent1q…jdwt npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks to @npub1ye5…knpr for contributing Umbrel support for Relatr. Now everyone can deploy their own instance from home without hassle. You just need to add the hzrd's community store by following the instructions here https://github.com/hzrd149/umbrel-community-app-store , install Relatr, and you'll be up and running. We are so excited to keep working and improving this to truly democratize WoT and foster a healthier ecosystem 💛 #nevent1q…y7wg npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM YES #YESTR#nevent1q…08fg npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Do you know about Wavefunc? It's a neat Nostr project that lets you listen to, discover, and share radio stations, and so much more. With ContextVM, Wavefunc can search for music metadata and show you what's currently playing in the radio stations. Plus, you can use their music metadata server on its own. Swing by https://wavefunc.live to see what it's all about. If you want to dive straight into the music metadata server, head over to https://contextvm.org/s/bb0707242a17a4be881919b3dcfea63f42aacedc3ff898a66be30af195ff32b2. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Further considering the pull vs. request/response (req/res) models, it is true that using already published trust assertion data can be convenient and easy to query with appropriate filters. However, one issue is that not all profiles are scored. For instance, a service provider might start publishing a large number of trust assertions, but the set will never be fully complete because it is dynamic, and it's impossible to anticipate which users need to be scored. Consider the example of a nostr feed we discussed: each profile should be complemented with trusted assertions. But what if one of the profiles in the feed doesn't have any trust assertion attached? In that case, the only solution is to request the trust computation from the service provider. We believe this might be the right balance. Relatr could publish trust assertion events for profiles that have already been computed and still rely on the req/res flow. In this scenario, a client could operate by first fetching already published trust assertions, and if a profile lacks one, request it. The advantage of this approach is that it can be perfectly integrated with the current Relatr model, as for each request, an event can be published. This way, client developers can choose to just fetch, fetch and request, or just request trust assertions. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Monetization should be up to the provider. We currently run the default Relatr instance for free, and we will continue to do so for the time being as we are still building the service. Once it is more mature, we can consider different ways to monetize it. On the other hand, monetization is already possible using ContextVM and it will be better integrated once CEP-8 is completed. https://github.com/ContextVM/contextvm-docs/issues/8 What are your thoughts on monetization? 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 During the process, we removed the persistent database where we were storing some CVM announcements. If you are running a CVM server, please rebroadcast or republish your announcements to our relay. This can be done by simply restarting the server.#nevent1q…526n npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We use Rely for the contextvm relay, and it has been quite stable and performant. We just upgraded to v1 🚀#nevent1q…jpff npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey! Yes, that could be a great idea. But there are some details that we should consider when evaluating this feature. The interaction with relatr is based on using JSON-RPC as defined in the ContextVM spec, similar to dvms, where the scores are computed at query time, and there is no requirement for persistence as nostr events. The idea behind this is to have freshly computed scores and control of the cache instead of relying on replaceable events that can become stale. This approach also avoids being affected by nostr broadcasting/propagation quirks, such as inconsistency in the last state of the published events where different relays might have different versions of the events. But yes, we could enhance this by publishing trusted assertions in some way. We have to think about what would be the best way to do this npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Q: Favorite packaging method? A: HTML There is no second best npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM 🚀 Exciting News! Introducing the Awesome ContextVM Repository https://image.nostr.build/228c9b476534f9ac6aa45fd51bbe04363746207b1a165525ba586ea016f86ece.jpg We are excited to announce the launch of the Awesome ContextVM repository! This curated list is a comprehensive collection of resources, projects, tools, and documentation for the ContextVM ecosystem. Whether you're a developer, enthusiast, or just curious about ContextVM, you'll find everything you need to get started and stay updated. The repository includes an introduction to ContextVM, and its key features. You'll find direct links to official resources, core projects, applications and services, developer tools, documentation, community and governance information, and articles and blog posts. The repository also provides guidelines on how you can contribute to this awesome list and help grow the ecosystem. You can find the Awesome ContextVM repository at https://github.com/contextvm/awesome We invite you to explore, contribute, and be part of this exciting journey! npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Nutoff Reworked: Now Powered by Coco Cashu https://image.nostr.build/bc235f4a49ffb6ff47e5570eae5fe655caeaa160587be87cab49e786cc50df8f.jpg We have rebuilt Nutoff from the ground up using Coco Cashu, a new high-level library created by @npub1mhc…c226 . Nutoff remains local-first, keeping your nuts off, but now offers complete mint management, true multimint support, seed phrase recovery, and more robust, event-driven operations, all thanks to Coco. Users can expect safer, more reliable wallet behavior and straightforward backup/restore functionality, with all sensitive data kept offline and never leaving your device, using CVM to enables remote invoice, payment, and management flows. How to Get Started: 1. Clone the repository: https://github.com/contextvm/nutoff-wallet 2. Open a terminal in the directory and install dependencies, ideally using Bun: `bun install` 3. Run the server: `bun start` 4. You will see a log in the console with your `SERVER PUBLIC KEY: <public-key>` 5. Navigate to contextvm.org/s/<public-key-of-your-wallet> to start using the wallet. With this running, you could use CtxCn to generate a client to your own taste, matching the interface that you like the most. The 'backend' will always remain the same, but you can write any UI/UX on top, like skins, without changing anything in your wallet For more detailed information, refer to the repository's README. Note: Coco-Cashu is currently in alpha. Use it at your own risk. - Coco-Cashu: https://github.com/cashubtc/coco - Nutoff: https://github.com/contextvm/nutoff-wallet npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Yes #YESTR#nevent1q…0ycz npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Run the mint on localhost > Use ContextVM to wrap its api > You have a mint addressable by pubkey and accessible through nostr. All calls use ephemeral events and are gift wrapped in the case of encryption npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Yes, Relatr is a CVM server available for everyone. You can integrate it into any client. Here is an example of how to integrate it easily into any TypeScript/JavaScript project. In reality, it's just JSON-RPC over Nostr, so you could integrate it in any language really. Little by little, we will be bringing more tools to make it as easy in other lenguage as it is in ts projects. #nevent1q…28nv 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 Thanks! 💛 that was a typo in our side, the service it's called Relatr npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM From where are you visiting the site? We checked with different tools and everything seems correct in our side. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Great idea! We will open an issue to track the progress of this feature 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 That's for sure; the key here is still that the trust is computed from a specific source pubkey. So, if there is a more relevant pubkey in the social graph than the impersonator's, it will rank higher because it will likely have more favorable validators. Definitely, this approach can be improved and strengthened. We could sample distances to a target pubkey from different direct contacts of the source pubkey to get more paths validated. The architecture will allow this thanks to the Nostr social graph lib by @npub1g53…drvk that we are using. Thanks for the feedback; it is very appreciated. As we mentioned, this is still an experiment, and we need to keep tweaking it to get more relevant results and metrics. 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 Hmm 🤔 maybe it's DNS propagation. It appears correct on our end. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM This sounds extremely fun and and cypherpunk af 🔥🔥 #nevent1q…q5r3 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hey! Thanks for your feedback. Yes, definitely the Relatr approach is more left side of the curve than Vertex or any other PageRank algorithm. However, the approach that Relatr is following is still consistent since the base of the score calculation is based on the distance between the source pubkey and the target pubkey. In the default instance we are running, the source pubkey is gigi, so in order for an attacker to impersonate someone, it will need gigi to follow them or a gigi's contact to follow it. But the farther the distance, the bigger the decay, so fundamentally an attacker would need to do some social engineering to make it closer to the source pubkey to some degree, which is not easily gameable, especially if the social graph realizes it is an attacker/impersonator and publishes a mute list with the attacker pubkey in it. The other validators are easily gameable in some way, yes, like valid NIP-05, NIP-10002 events published, yes, that's easy to game, but the weight it has in the score calculation is little compared to social graph distance. There are also other validators that aren't easily gameable, like reciprocity (source and target follow each other), and we are thinking in adding some more like zaps and activity. In summary, this is an experiment, but so far it is working pretty well as tie breaker to determine which pubkey is more likely to be an impersonator or the "real" one, and ideally everyone runs an instance that sets their pubkey as source so the trust score comes from their perspective. On the other hand, yes, the other relevant Jack didn't appear because they weren't being discovered during the first profile metadata sync that Relatr does. This is a bug; it's still early days, but after searching explicitly for them, they now appear as they are added to the metadata DB. Also, when you look for Jack. https://image.nostr.build/a5790c5317a814be603a317b720ddac244fe8dc43279dd0fb18f20feb22a8854.png npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM They are based on the social graph distance between you and the source pubkey, as well as other objective validation metrics like nip05, some events, LN address, etc. You can find more detailed information in the article or the about page. https://relatr.xyz/about npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM What's the problem? npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM That's not a problem. The computed rank is just a way to deal with impersonators from a given perspective (source key). It shouldn't be seen as a global trust score or anything like that. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM You can read more about how this is done in the article, but essentially, it involves social graph distance plus some validations, such as certain events and indicators that signal common best practices in Nostr. It's not perfect; we are still experimenting. The idea is to have a way to determine the most trustworthy profile from a given perspective (source pubkey) to deal with impersonators. npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Yes, just that. We are experimenting with the validators. Do you think that is a meaningful metric? npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks! Yes, that is a bug 😅 we are on it. About your NIP-05 address, that's not the reason. It also appears invalid in different clients, including njump.me. Check CORS npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM No, root nip05 are just the addresses like '[email protected] ' 👍 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM The distance weight is the importance that the social graph distance has over the final score. In this case, it is almost half of the weight, and the other validators make up the rest of the score. There is more information in the article we wrote and on the about page: https://www.relatr.xyz/about , or just ask if you have any other doubt! 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 Thanks! we will be writing and publishing workshop soon, stay tuned npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Introducing CtxCn, a powerful command-line utility designed to make developers' (and anyone really) lives easier. https://image.nostr.build/77aa773c5671045ad723cf08da98e6733ade9859428627a8d687825b413f23ff.jpg Read the blog article we wrote: #naddr1qv…nq8u Also: https://nostr.at/naddr1qvzqqqr4gupzq6ehsrhjjuh885mshp9ru50842dwxjl5z2fcmnaan30k8v3pg9kgqq25set9ddxy2s33wq68y4fkx9hxwcn4geeyszanq8u And in our blog: https://www.contextvm.org/blog/HeekLEB1p4rU61ngbuFrH npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Cooking 🍳 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Not yet! we will need to raise some atmospheric ballons with lora/halow mesh devices then npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Not really, it just means that the only piece of the stack that can see the IP of the server is the relay, as the server connects to the relay to subscribe to new requests. The same is true when you connect to a relay; it can see your IP. The relay is just a web server, so when a user, client, server, or anything else connects to it, it can see their IP address. There is no translation from npub to IP address in the CVM protocol npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM fair enough npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Hahaha, definitely worth a crack. You can also prepare a simple server just to echo something or add two numbers as a way to take advantage of the experiment environment, the plane. It will be a success if, during the flight, you share the pubkeys of the servers and we can just call them using the contextvm.org website npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Yes! #YESTR #nevent1q…g9a4 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Imagine deploying the backend of a game mid-flight, just by connecting your laptop or the server hosting device (could be your phone) to the plane's Wi-Fi. It's mind blowing! 🤯 We can't wait to see the results of this exciting test experiment. #nevent1q…d8p8 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We have a signal group where we discuss topics, clear doubts, and announce stuff. Join and don't be afraid to ask anything 💛 https://signal.group/#CjQKIOgvfFJf8ZFZ1SsMx7teFqNF73sZ9Elaj_v5i6RSjDHmEhAB3wO1Rg-0gLNdusnb3wLR npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM We can try! ContextVM is a protocol that makes it possible for services to be reachable through internet by clients without complicated setups or any permissions. Imagine that you have a lemonade stand, and you want people to be able to buy from your lemonade stand. Now imagine that your lemonade stand is digital, and the internet is the street where the stand is placed. In the traditional way of building things, you'll need to do loads of complex configuration and even ask for permission from the owner of the piece of infrastructure that allows you to connect to the internet to enable users to see your stand and buy from it. With ContextVM, it's as easy as making the lemonade and just opening the stand. Thanks to nostr relays, people would be able to see and buy lemonade from you without any hassle. I hope this is clear enough. We also recorded a little demo that goes through the different pieces that allow you to have this. Maybe that also helps. #nevent1q…zk8p 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 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM ContextVM SDK v0.1.31 Release Notes We are excited to announce the release of ContextVM SDK v0.1.31! This update brings powerful new features, significant performance enhancements, and important bug fixes to improve the developer experience and the robustness of your applications. 🚀 New Features - Stateless Mode for Nostr Client Transport To optimize performance and reduce network overhead, we've introduced a stateless mode for the 'NostrClientTransport'. Previously, clients had to complete a handshake before making requests. Now, you can bypass this initialization step, allowing clients to start making method calls immediately. This is especially beneficial for applications requiring fast startup times. For more details, check out our documentation: https://docs.contextvm.org/ts-sdk/transports/nostr-client-transport/#stateless-mode - Capability Exclusion for Whitelisting We've enhanced our server's whitelisting capabilities to provide more granular control. You can now specify an array of `excludedCapabilities` that will not require public key whitelisting. This is perfect for servers that expose a mix of private methods (for whitelisted keys) and public methods (open to everyone), offering greater flexibility in defining your security policies. 🐛 Bug Fixes & Improvements - Enhanced Server Reliability for Long-Lived Connections: We have significantly improved the reliability of deployed servers by overhauling session management for long-lived connections. This includes configurable session cleanup and faster client lookups, leading to greater stability and performance. - Enhanced Nostr Performance: The Nostr transports now benefits from significant performance improvements, thanks to the new stateless client mode and optimized server-side session management. - Correct Unauthorized Error Handling: Servers now correctly send a JSON-RPC error (`-32000`, 'Unauthorized') when a request is made by a non-whitelisted public key, ensuring clients receive clear and standardized feedback. - High-Performance Logging with Pino: Replaced the custom logger with Pino for structured, high-performance logging with flexible configuration options. - Relay Pool Update: The `applesauce-relay` dependency has been updated to v4, and the SDK has been adapted to its new API, improving relay management and debugging. --- This release marks another step forward in making the ContextVM SDK more powerful, secure, and easy to use. We thank our contributors and community for their valuable feedback. The ContextVM Team npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Here is a short demo video walking through the ContextVM ecosystem. In it, we demonstrate some fundamental concepts, including creating a Cashu wallet, wrapping its API in an MCP server, and exposing it as a ContextVM so it can be used from Nostr. We also introduce a new tool we are working on CtxCn, which allows you to easily integrate any CVM server into any TypeScript project. Additionally, we show how to create a demo website from a single prompt that just works. This is just a quick overview of what is possible with ContextVM. More details about what we have been building during #sovEng 5 will be available soon. On this video: - https://github.com/ContextVM/sdk - https://github.com/ContextVM/ctxcn - https://github.com/gzuuus/nutoff-wallet https://blossom.primal.net/db5731558295a9c919327416b8a48e2e189e4ef6603cef636c92f67428a2ae6e.mp4 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Soon we will be writing a recap of what has been built using CVM during @npub1s0v…rmq5 5. Currently, it is a quite considerable list of projects that are truly groundbreaking, or at least the foundations of them. We will continue to build, improve, and push harder in the direction of freedom. Stay tuned #nevent1q…0gp2 npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Soveng has been incredible, with loads of ideas and experimentation around new ways to architect systems. This is an amazing example of what has been going on. Beacon is the Trojan horse of walled gardens and it uses CVM as a core part of it 🔥 #nevent1q…xchs npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Thanks @npub1jss…fmzy for mentioning contextvm in the last episode of Good Stuff (Good Stuff 24 - Hope, Truth and Abundance with Jeff Booth). It was a great episode, by the way! You can listen to it on any podcasting platform; the mention of contextvm is around minute 55. Quoting (transcript from yt): "...So like MCP servers are like one of the big things inside no uh inside AI at the moment and like his realization was that um one of the things you can do with uh MCP is that it specifies a protocol that's kind of like remote JSON RPC. So how do I tool call other things from this program? But it's agnostic to the transport protocol. So he made nostr protocol which means that now you don't need APIs. You don't need to buy some servers. You can just spin something up on your computer and give it a public key and then somebody can talk to it, so all of a sudden like infrastructure is addressable by public key, doesn't need IP addresses like just maintains like websocket connections and you have these tools just available anywhere. So I in that demo I ran the whole thing again from this Mac Mini. There's no you know I'm just in an Airbnb. There's no fancy networking going on and it's like all right I'm never using an API and get like everything is now public key addressable..." https://www.youtube.com/watch?v=urNNHN2CT4A npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM The discussion about pricing and payments flows (CEP-8) is happening at https://github.com/ContextVM/contextvm-docs/pull/9 The proposal contemplates a 'matching' system to handle the multiplicity of possible payment methods that could exist. The 'matching' mechanism is based on a reference list of payment method identifiers. It's like a dating app, but for payment methods. For example, if your server supports the payment method identifier 'bitcoin-lingthing-bolt11', it emits a payment request including it, and the client matches if it supports that payment method. If it supports the method, it's a match! Beautiful 💛 Please join the conversation and provide feedback if you have any; it's highly appreciated npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Migration complete, our relay and servers are up and running again. #nevent1q…yu5z npub1dvmcpmefwtnn6dctsj3728n64xhrf06p9yude77echmrkgs5zmyqw33jdm ContextVM Our relay and deployed servers are experiencing shortages due to a constant DDoS attack on our VPS provider, LNVPS.net. This has been happening for several days and uptime hasn't been good. We're working on migrating the infrastructure to a different provider.