Golang jsonrpc2 server where is it listending?

I see:

HandlerWithError(s.Handle)

    // Create a new jsonrpc2 stream server
    <-jsonrpc2.NewConn(
        context.Background(),
        jsonrpc2.NewBufferedStream(os.Stdin, jsonrpc2.VSCodeObjectCodec{}),
        handler).DisconnectNotify()
}

That means your code is using JSON-RPC over standard input and output (stdin/stdout), not over a network connection.
When you use os.Stdin as a parameter to jsonrpc2.NewBufferedStream, you are specifying that input should come from the standard input of the process running the server. And the response will be sent to the standard output.

So, the server is not listening on any network port. It is interacting with data that is sent directly to its standard input and output. That is often used for inter-process communication, for example, when you want one process to call the server process and receive a response.
See for instance "Go: bidirectional communication with another process?" or davidelorenzoli/stdin-stdout-ipc.

If you want your JSON-RPC server to listen on a network port, you will need to set up a network connection in Go using the net package. You will also need to modify your client script to send its requests to the correct network port, rather than sending an HTTP request to a URL.

package main

import (
    "context"
    "net"
    "log"
    "sync"

    "github.com/sourcegraph/jsonrpc2"
)

type LSPServer struct {
    // The symmetric connection
    conn jsonrpc2.Conn

    // Check if the connection is available
    connMutex sync.Mutex

    // shutdown
    shutdown bool
}

func NewLSPServer() *LSPServer {
    return &LSPServer{}
}

func (s *LSPServer) Initialize(ctx context.Context) error {
    // Initialize here if needed
    return nil
}

func (s *LSPServer) Handle(context.Context, *jsonrpc2.Conn, *jsonrpc2.Request) (result interface{}, err error) {
    fmt.Println("Handling request...")
    // Handle something
    return nil, nil
}

func (s *LSPServer) Serve(ctx context.Context) {
    fmt.Println("Starting LSP server...")
    
    // Listen on TCP port 4389 on all available unicast and
    // anycast IP addresses of the local system.
    l, err := net.Listen("tcp", "localhost:4389")
    if err != nil {
        log.Fatal(err)
    }
    defer l.Close()

    for {
        // Wait for a connection.
        conn, err := l.Accept()
        if err != nil {
            log.Fatal(err)
        }

        // Handle the connection in a new goroutine.
        go func(c net.Conn) {
            // Create a new jsonrpc2 stream server
            handler := jsonrpc2.HandlerWithError(s.Handle)
            <-jsonrpc2.NewConn(
                ctx,
                jsonrpc2.NewBufferedStream(c, jsonrpc2.VSCodeObjectCodec{}),
                handler).DisconnectNotify()
            c.Close()
        }(conn)
    }
}

func main() {
    // Create a new LSP server
    server := NewLSPServer()
    go server.Serve(context.Background()) // run Serve in a separate goroutine
    select {} // wait forever
}

That is a basic example, where the Serve method creates a TCP listener that listens on port 4389 of the localhost. It then enters a loop where it waits for connections, and when it gets one, it starts a new goroutine to handle that connection using your JSON-RPC server.

On the client side, you would need to open a TCP connection to the server, write your JSON-RPC request to that connection, then read the response.

You cannot use the requests library as in your Python script because that is for HTTP requests, not raw TCP connections.
You will need to use the socket library in Python, or a similar library in your client’s language, to create a TCP connection and send/receive data over it.

But keep in mind, an LSP (Language Server Protocol) operates over stdin/stdout rather than network sockets.
That is because LSP servers are typically launched as subprocesses by the editor/IDE and communicate directly through these channels. So depending on your use-case, the original stdin/stdout method might be more appropriate.