### Instruction:
Develop a Golang application that uses the Twitter API to stream tweets containing specified keywords, performs sentiment analysis on the tweet text, and stores the results in a MongoDB database. The application should also provide an endpoint for querying the stored data based on keyword and sentiment score.

### Response:

To develop this Golang application, you'll need to follow these steps:

1. Set up your development environment
2. Register a Twitter Developer account and create an App
3. Implement the Twitter API client in Go
4. Perform sentiment analysis using a third-party library or service
5. Store the results in MongoDB
6. Create an HTTP server with an endpoint for querying the stored data

Here's a sample implementation of the required functionality:

```go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/dghubble/go-twitter/twitter"
	"github.com/dghubble/oauth1"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type TweetSentiment struct {
	TweetID       int64   `bson:"tweet_id"`
	Text          string  `bson:"text"`
	Sentiment     float64 `bson:"sentiment"`
	Keyword       string  `bson:"keyword"`
}

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}

	consumerKey := os.Getenv("TWITTER_CONSUMER_KEY")
	consumerSecret := os.Getenv("TWITTER_CONSUMER_SECRET")
	accessToken := os.Getenv("TWITTER_ACCESS_TOKEN")
	accessSecret := os.Getenv("TWITTER_ACCESS_SECRET")

	config := oauth1.NewConfig(consumerKey, consumerSecret)
	token := oauth1.NewToken(accessToken, accessSecret)
	httpClient := config.Client(oauth1.NoContext, token)

	client := twitter.NewClient(httpClient)

	keywords := []string{"golang", "mongodb"}

	streamFilterParams := &twitter.StreamFilterParams{
		Track:         keywords,
		StallWarnings: twitter.Bool(true),
	}

	stream, err := client.Streams.Filter(streamFilterParams)
	if err != nil {
		log.Fatal(err)
	}

	demux := twitter.NewSwitchDemux()
	demux.Tweet = func(tweet *twitter.Tweet) {
		sentiment := analyzeSentiment(tweet.Text)
		tweetSentiment := TweetSentiment{
			TweetID:   tweet.ID,
			Text:      tweet.Text,
			Sentiment: sentiment,
			Keyword:   findKeyword(keywords, tweet.Text),
		}
		storeTweetSentiment(tweetSentiment)
	}

	go demux.HandleChan(stream.Messages)

	http.HandleFunc("/query", queryHandler)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func analyzeSentiment(text string) float64 {
	// Implement your sentiment analysis logic here.
	// You can use a third-party library or service like TextBlob, Google Cloud Natural Language API, etc.
	return 0.0
}

func findKeyword(keywords []string, text string) string {
	for _, keyword := range keywords {
		if strings.Contains(strings.ToLower(text), strings.ToLower(keyword)) {
			return keyword
		}
	}
	return ""
}

func storeTweetSentiment(tweetSentiment TweetSentiment) {
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("tweets").Collection("sentiments")

	insertResult, err := collection.InsertOne(context.Background(), tweetSentiment)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Inserted tweet with ID:", insertResult.InsertedID)
}

func queryHandler(w http.ResponseWriter, r *http.Request) {
	keyword := r.URL.Query().Get("keyword")
	minSentiment := r.URL.Query().Get("min_sentiment")

	filter := bson.M{"keyword": keyword, "sentiment": bson.M{"$gte": minSentiment}}

	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	client, err := mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("tweets").Collection("sentiments")

	cursor, err := collection.Find(context.Background(), filter)
	if err != nil {
		log.Fatal(err)
	}

	var results []TweetSentiment
	err = cursor.All(context.Background(), &results)
	if err != nil {
		log.Fatal(err)
	}

	json.NewEncoder(w).Encode(results)
}
```

Make sure to replace the placeholder sentiment analysis function `analyzeSentiment` with a real implementation using a third-party library or service.

To run this application, you'll need to create a `.env` file in your project directory containing your Twitter API credentials:

```
TWITTER_CONSUMER_KEY=your_consumer_key
TWITTER_CONSUMER_SECRET=your_consumer_secret
TWITTER_ACCESS_TOKEN=your_access_token
TWITTER_ACCESS_SECRET=your_access_secret
```

You'll also need to install the required dependencies:

```sh
go get github.com/dghubble/go-twitter/twitter
go get github.com/dghubble/oauth1
go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/mongo
```

Now you can build and run the application:

```sh
go build -o main
./main
```

The application will start streaming tweets containing the specified keywords, perform sentiment analysis on them, and store the results in MongoDB. You can query the stored data by sending an HTTP request to the `/query` endpoint with the desired keyword and minimum sentiment score as query parameters:

```
http://localhost:8080/query?keyword=golang&min_sentiment=0.5
```